Coverage Report - com.googlecode.sparkleg.SparqlParser
 
Classes in this File Line Coverage Branch Coverage Complexity
SparqlParser
84%
7948/9351
24%
1203/4886
11,608
SparqlParser$DFA4
91%
11/12
N/A
N/A
11,608
SparqlParser$add_return
0%
0/2
N/A
N/A
11,608
SparqlParser$additiveExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$additiveOperator_return
100%
2/2
N/A
N/A
11,608
SparqlParser$aggregate_return
100%
2/2
N/A
N/A
11,608
SparqlParser$anon_return
100%
2/2
N/A
N/A
11,608
SparqlParser$argList_return
100%
2/2
N/A
N/A
11,608
SparqlParser$askQuery_return
100%
2/2
N/A
N/A
11,608
SparqlParser$baseDecl_return
100%
2/2
N/A
N/A
11,608
SparqlParser$bind_return
100%
2/2
N/A
N/A
11,608
SparqlParser$bindingValueList_return
100%
2/2
N/A
N/A
11,608
SparqlParser$bindingValue_return
100%
2/2
N/A
N/A
11,608
SparqlParser$bindingsClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$blankNode_return
100%
2/2
N/A
N/A
11,608
SparqlParser$booleanLiteral_return
100%
2/2
N/A
N/A
11,608
SparqlParser$brackettedExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$builtInCall_return
100%
2/2
N/A
N/A
11,608
SparqlParser$clear_return
100%
2/2
N/A
N/A
11,608
SparqlParser$conditionalAndExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$conditionalOrExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$constraint_return
100%
2/2
N/A
N/A
11,608
SparqlParser$constructQuery_return
100%
2/2
N/A
N/A
11,608
SparqlParser$constructTemplate_return
100%
2/2
N/A
N/A
11,608
SparqlParser$constructTriples_return
100%
2/2
N/A
N/A
11,608
SparqlParser$copy_return
0%
0/2
N/A
N/A
11,608
SparqlParser$create_return
0%
0/2
N/A
N/A
11,608
SparqlParser$datasetClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$deleteClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$deleteData_return
100%
2/2
N/A
N/A
11,608
SparqlParser$deleteWhere_return
100%
2/2
N/A
N/A
11,608
SparqlParser$delete_return
100%
2/2
N/A
N/A
11,608
SparqlParser$describeQuery_return
100%
2/2
N/A
N/A
11,608
SparqlParser$drop_return
100%
2/2
N/A
N/A
11,608
SparqlParser$existsFunction_return
100%
2/2
N/A
N/A
11,608
SparqlParser$expressionList_return
100%
2/2
N/A
N/A
11,608
SparqlParser$expression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$filter_return
100%
2/2
N/A
N/A
11,608
SparqlParser$functionCall_return
100%
2/2
N/A
N/A
11,608
SparqlParser$graphGraphPattern_return
100%
2/2
N/A
N/A
11,608
SparqlParser$graphNode_return
100%
2/2
N/A
N/A
11,608
SparqlParser$graphOrDefault_return
0%
0/2
N/A
N/A
11,608
SparqlParser$graphPatternNotTriples_return
100%
2/2
N/A
N/A
11,608
SparqlParser$graphRefAll_return
100%
2/2
N/A
N/A
11,608
SparqlParser$graphRef_return
100%
2/2
N/A
N/A
11,608
SparqlParser$graphTerm_return
100%
2/2
N/A
N/A
11,608
SparqlParser$groupClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$groupCondition_return
100%
2/2
N/A
N/A
11,608
SparqlParser$groupGraphPatternSubDetail_return
100%
2/2
N/A
N/A
11,608
SparqlParser$groupGraphPatternSub_return
100%
2/2
N/A
N/A
11,608
SparqlParser$groupGraphPattern_return
100%
2/2
N/A
N/A
11,608
SparqlParser$groupOrUnionGraphPattern_return
100%
2/2
N/A
N/A
11,608
SparqlParser$havingClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$insertClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$insert_return
100%
2/2
N/A
N/A
11,608
SparqlParser$iriRefOrFunction_return
100%
2/2
N/A
N/A
11,608
SparqlParser$iriRef_return
100%
2/2
N/A
N/A
11,608
SparqlParser$limitClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$limitOffsetClauses_return
100%
2/2
N/A
N/A
11,608
SparqlParser$load_return
0%
0/2
N/A
N/A
11,608
SparqlParser$minusGraphPattern_return
100%
2/2
N/A
N/A
11,608
SparqlParser$modify_return
100%
2/2
N/A
N/A
11,608
SparqlParser$move_return
0%
0/2
N/A
N/A
11,608
SparqlParser$multiplicativeExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$multiplicativeOperator_return
100%
2/2
N/A
N/A
11,608
SparqlParser$nil_return
100%
2/2
N/A
N/A
11,608
SparqlParser$notExistsFunction_return
100%
2/2
N/A
N/A
11,608
SparqlParser$numericExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$numericLiteralNegative_return
100%
2/2
N/A
N/A
11,608
SparqlParser$numericLiteralPositive_return
100%
2/2
N/A
N/A
11,608
SparqlParser$numericLiteralUnsigned_return
100%
2/2
N/A
N/A
11,608
SparqlParser$numericLiteral_return
100%
2/2
N/A
N/A
11,608
SparqlParser$objectList_return
100%
2/2
N/A
N/A
11,608
SparqlParser$offsetClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$optionalGraphPattern_return
100%
2/2
N/A
N/A
11,608
SparqlParser$orderClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$orderCondition_return
100%
2/2
N/A
N/A
11,608
SparqlParser$pathEltOrInverse_return
100%
2/2
N/A
N/A
11,608
SparqlParser$pathElt_return
100%
2/2
N/A
N/A
11,608
SparqlParser$pathMod_return
100%
2/2
N/A
N/A
11,608
SparqlParser$pathNegatedPropertySet_return
100%
2/2
N/A
N/A
11,608
SparqlParser$pathOneInPropertySet_return
100%
2/2
N/A
N/A
11,608
SparqlParser$pathPrimary_return
100%
2/2
N/A
N/A
11,608
SparqlParser$pathSequence_return
100%
2/2
N/A
N/A
11,608
SparqlParser$path_return
100%
2/2
N/A
N/A
11,608
SparqlParser$prefixDecl_return
100%
2/2
N/A
N/A
11,608
SparqlParser$prefixedName_return
100%
2/2
N/A
N/A
11,608
SparqlParser$primaryExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$prologue_return
100%
2/2
N/A
N/A
11,608
SparqlParser$propertyListNotEmptyDetails_return
100%
2/2
N/A
N/A
11,608
SparqlParser$propertyListNotEmptyPath_return
100%
2/2
N/A
N/A
11,608
SparqlParser$propertyListNotEmpty_return
100%
2/2
N/A
N/A
11,608
SparqlParser$quadPattern_return
100%
2/2
N/A
N/A
11,608
SparqlParser$quadsDetails_return
100%
2/2
N/A
N/A
11,608
SparqlParser$quadsNotTriples_return
100%
2/2
N/A
N/A
11,608
SparqlParser$quads_return
100%
2/2
N/A
N/A
11,608
SparqlParser$query_return
100%
2/2
N/A
N/A
11,608
SparqlParser$rdfLiteral_return
100%
2/2
N/A
N/A
11,608
SparqlParser$regexExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$relationalExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$selectClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$selectQuery_return
100%
2/2
N/A
N/A
11,608
SparqlParser$selectVariables_return
100%
2/2
N/A
N/A
11,608
SparqlParser$serviceGraphPattern_return
100%
2/2
N/A
N/A
11,608
SparqlParser$solutionModifier_return
100%
2/2
N/A
N/A
11,608
SparqlParser$string_return
100%
2/2
N/A
N/A
11,608
SparqlParser$subSelect_return
100%
2/2
N/A
N/A
11,608
SparqlParser$subStringExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$triplesBlock_return
100%
2/2
N/A
N/A
11,608
SparqlParser$triplesNode_return
100%
2/2
N/A
N/A
11,608
SparqlParser$triplesSameSubjectPath_return
100%
2/2
N/A
N/A
11,608
SparqlParser$triplesSameSubject_return
100%
2/2
N/A
N/A
11,608
SparqlParser$triplesTemplate_return
100%
2/2
N/A
N/A
11,608
SparqlParser$unaryExpression_return
100%
2/2
N/A
N/A
11,608
SparqlParser$update_return
100%
2/2
N/A
N/A
11,608
SparqlParser$usingClause_return
100%
2/2
N/A
N/A
11,608
SparqlParser$valueLogical_return
100%
2/2
N/A
N/A
11,608
SparqlParser$varOrIRIref_return
100%
2/2
N/A
N/A
11,608
SparqlParser$varOrTerm_return
100%
2/2
N/A
N/A
11,608
SparqlParser$var_return
100%
2/2
N/A
N/A
11,608
SparqlParser$verbPath_return
100%
2/2
N/A
N/A
11,608
SparqlParser$verbSimpleOrPath_return
100%
2/2
N/A
N/A
11,608
SparqlParser$verbSimple_return
100%
2/2
N/A
N/A
11,608
SparqlParser$verb_return
0%
0/2
N/A
N/A
11,608
SparqlParser$whereClause_return
100%
2/2
N/A
N/A
11,608
 
 1   
 // $ANTLR 3.4 com\\googlecode\\sparkleg\\Sparql.g 2011-12-25 17:43:15
 2   
 
 3   
     package com.googlecode.sparkleg;
 4   
 
 5   
 
 6   
 import org.antlr.runtime.*;
 7   
 import java.util.Stack;
 8   
 import java.util.List;
 9   
 import java.util.ArrayList;
 10   
 
 11   
 import org.antlr.runtime.tree.*;
 12   
 
 13   
 
 14   
 /**
 15   
  * @author Simone Tripodi   (simone.tripodi)
 16   
  * @author Michele Mostarda (michele.mostarda)
 17   
  * @author Juergen Pfundt   (Juergen.Pfundt)
 18   
  * @version $Id: Sparql.g 226 2011-10-22 21:13:52Z Juergen.Pfundt@gmail.com $
 19   
  */
 20   
 @SuppressWarnings({"all", "warnings", "unchecked"})
 21   
 public class SparqlParser extends Parser {
 22  1 
     public static final String[] tokenNames = new String[] {
 23   
         "<invalid>", "<EOR>", "<DOWN>", "<UP>", "A", "ABS", "ADD", "ALL", "AND", "ANY", "ARG_LIST", "AS", "ASC", "ASK", "ASTERISK", "AVG", "BASE", "BIND", "BINDINGS", "BINDING_VALUE", "BLANK_NODE", "BLANK_NODE_LABEL", "BNODE", "BOUND", "BRACKETTED_EXPRESSION", "BY", "CEIL", "CLEAR", "CLOSE_BRACE", "CLOSE_CURLY_BRACE", "CLOSE_SQUARE_BRACKET", "COALESCE", "COLLECTION", "COMMA", "COMMENT", "CONCAT", "CONSTRUCT", "CONSTRUCT_TRIPLES", "CONTAINS", "COPY", "COUNT", "CREATE", "DATA", "DATATYPE", "DAY", "DECIMAL", "DECIMAL_NEGATIVE", "DECIMAL_POSITIVE", "DEFAULT", "DELETE", "DESC", "DESCRIBE", "DIGIT", "DISTINCT", "DIVIDE", "DOT", "DOUBLE", "DOUBLE_NEGATIVE", "DOUBLE_POSITIVE", "DROP", "ECHAR", "ENCODE_FOR_URI", "EOL", "EQUAL", "EXISTS", "EXPONENT", "EXPRESSION_LIST", "FALSE", "FILTER", "FLOOR", "FROM", "FUNCTION", "GRAPH", "GREATER", "GREATER_EQUAL", "GROUP", "GROUP_BY", "GROUP_CONCAT", "GROUP_CONDITION", "GROUP_GRAPH_PATTERN", "HAVING", "HOURS", "IF", "IN", "INSERT", "INTEGER", "INTEGER_NEGATIVE", "INTEGER_POSITIVE", "INTO", "INVERSE", "IRI", "IRI_REF", "IRI_REF_CHARACTERS", "ISBLANK", "ISIRI", "ISLITERAL", "ISNUMERIC", "ISURI", "LANG", "LANGMATCHES", "LANGTAG", "LCASE", "LESS", "LESS_EQUAL", "LIMIT", "LOAD", "MAX", "MD5", "MIN", "MINUS", "MINUS_KEYWORD", "MINUTES", "MODIFY", "MONTH", "MOVE", "NAMED", "NEGATION", "NOT", "NOT_EQUAL", "NOT_EXISTS", "NOW", "OBJECT", "OFFSET", "OPEN_BRACE", "OPEN_CURLY_BRACE", "OPEN_SQUARE_BRACKET", "OPTIONAL", "OR", "ORDER", "ORDER_BY", "ORDER_CONDITION", "PATH", "PATH_NEGATED", "PATH_PRIMARY", "PATH_SEQUENCE", "PIPE", "PLUS", "PNAME_LN", "PNAME_NS", "PN_CHARS", "PN_CHARS_BASE", "PN_CHARS_U", "PN_LOCAL", "PN_PREFIX", "PREDICATE", "PREFIX", "PROLOGUE", "QUERY", "QUESTION_MARK", "RAND", "REDUCED", "REFERENCE", "REGEX", "REPLACE", "ROUND", "SAMETERM", "SAMPLE", "SECONDS", "SELECT", "SELECT_CLAUSE", "SEMICOLON", "SEPARATOR", "SERVICE", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512", "SIGN", "SILENT", "STR", "STRAFTER", "STRBEFORE", "STRDT", "STRENDS", "STRING_LITERAL1", "STRING_LITERAL2", "STRING_LITERAL_LONG1", "STRING_LITERAL_LONG2", "STRLANG", "STRLEN", "STRSTARTS", "SUBJECT", "SUBSELECT", "SUBSTR", "SUM", "TIMEZONE", "TO", "TRIPLES_BLOCK", "TRIPLES_NODE", "TRIPLES_SAME_SUBJECT", "TRIPLES_TEMPLATE", "TRUE", "TZ", "UCASE", "UNARY", "UNDEF", "UNION", "UPDATE", "URI", "USING", "VAR", "VAR1", "VAR2", "VARNAME", "WHERE", "WHERE_CLAUSE", "WITH", "WS", "YEAR"
 24   
     };
 25   
 
 26   
     public static final int EOF=-1;
 27   
     public static final int A=4;
 28   
     public static final int ABS=5;
 29   
     public static final int ADD=6;
 30   
     public static final int ALL=7;
 31   
     public static final int AND=8;
 32   
     public static final int ANY=9;
 33   
     public static final int ARG_LIST=10;
 34   
     public static final int AS=11;
 35   
     public static final int ASC=12;
 36   
     public static final int ASK=13;
 37   
     public static final int ASTERISK=14;
 38   
     public static final int AVG=15;
 39   
     public static final int BASE=16;
 40   
     public static final int BIND=17;
 41   
     public static final int BINDINGS=18;
 42   
     public static final int BINDING_VALUE=19;
 43   
     public static final int BLANK_NODE=20;
 44   
     public static final int BLANK_NODE_LABEL=21;
 45   
     public static final int BNODE=22;
 46   
     public static final int BOUND=23;
 47   
     public static final int BRACKETTED_EXPRESSION=24;
 48   
     public static final int BY=25;
 49   
     public static final int CEIL=26;
 50   
     public static final int CLEAR=27;
 51   
     public static final int CLOSE_BRACE=28;
 52   
     public static final int CLOSE_CURLY_BRACE=29;
 53   
     public static final int CLOSE_SQUARE_BRACKET=30;
 54   
     public static final int COALESCE=31;
 55   
     public static final int COLLECTION=32;
 56   
     public static final int COMMA=33;
 57   
     public static final int COMMENT=34;
 58   
     public static final int CONCAT=35;
 59   
     public static final int CONSTRUCT=36;
 60   
     public static final int CONSTRUCT_TRIPLES=37;
 61   
     public static final int CONTAINS=38;
 62   
     public static final int COPY=39;
 63   
     public static final int COUNT=40;
 64   
     public static final int CREATE=41;
 65   
     public static final int DATA=42;
 66   
     public static final int DATATYPE=43;
 67   
     public static final int DAY=44;
 68   
     public static final int DECIMAL=45;
 69   
     public static final int DECIMAL_NEGATIVE=46;
 70   
     public static final int DECIMAL_POSITIVE=47;
 71   
     public static final int DEFAULT=48;
 72   
     public static final int DELETE=49;
 73   
     public static final int DESC=50;
 74   
     public static final int DESCRIBE=51;
 75   
     public static final int DIGIT=52;
 76   
     public static final int DISTINCT=53;
 77   
     public static final int DIVIDE=54;
 78   
     public static final int DOT=55;
 79   
     public static final int DOUBLE=56;
 80   
     public static final int DOUBLE_NEGATIVE=57;
 81   
     public static final int DOUBLE_POSITIVE=58;
 82   
     public static final int DROP=59;
 83   
     public static final int ECHAR=60;
 84   
     public static final int ENCODE_FOR_URI=61;
 85   
     public static final int EOL=62;
 86   
     public static final int EQUAL=63;
 87   
     public static final int EXISTS=64;
 88   
     public static final int EXPONENT=65;
 89   
     public static final int EXPRESSION_LIST=66;
 90   
     public static final int FALSE=67;
 91   
     public static final int FILTER=68;
 92   
     public static final int FLOOR=69;
 93   
     public static final int FROM=70;
 94   
     public static final int FUNCTION=71;
 95   
     public static final int GRAPH=72;
 96   
     public static final int GREATER=73;
 97   
     public static final int GREATER_EQUAL=74;
 98   
     public static final int GROUP=75;
 99   
     public static final int GROUP_BY=76;
 100   
     public static final int GROUP_CONCAT=77;
 101   
     public static final int GROUP_CONDITION=78;
 102   
     public static final int GROUP_GRAPH_PATTERN=79;
 103   
     public static final int HAVING=80;
 104   
     public static final int HOURS=81;
 105   
     public static final int IF=82;
 106   
     public static final int IN=83;
 107   
     public static final int INSERT=84;
 108   
     public static final int INTEGER=85;
 109   
     public static final int INTEGER_NEGATIVE=86;
 110   
     public static final int INTEGER_POSITIVE=87;
 111   
     public static final int INTO=88;
 112   
     public static final int INVERSE=89;
 113   
     public static final int IRI=90;
 114   
     public static final int IRI_REF=91;
 115   
     public static final int IRI_REF_CHARACTERS=92;
 116   
     public static final int ISBLANK=93;
 117   
     public static final int ISIRI=94;
 118   
     public static final int ISLITERAL=95;
 119   
     public static final int ISNUMERIC=96;
 120   
     public static final int ISURI=97;
 121   
     public static final int LANG=98;
 122   
     public static final int LANGMATCHES=99;
 123   
     public static final int LANGTAG=100;
 124   
     public static final int LCASE=101;
 125   
     public static final int LESS=102;
 126   
     public static final int LESS_EQUAL=103;
 127   
     public static final int LIMIT=104;
 128   
     public static final int LOAD=105;
 129   
     public static final int MAX=106;
 130   
     public static final int MD5=107;
 131   
     public static final int MIN=108;
 132   
     public static final int MINUS=109;
 133   
     public static final int MINUS_KEYWORD=110;
 134   
     public static final int MINUTES=111;
 135   
     public static final int MODIFY=112;
 136   
     public static final int MONTH=113;
 137   
     public static final int MOVE=114;
 138   
     public static final int NAMED=115;
 139   
     public static final int NEGATION=116;
 140   
     public static final int NOT=117;
 141   
     public static final int NOT_EQUAL=118;
 142   
     public static final int NOT_EXISTS=119;
 143   
     public static final int NOW=120;
 144   
     public static final int OBJECT=121;
 145   
     public static final int OFFSET=122;
 146   
     public static final int OPEN_BRACE=123;
 147   
     public static final int OPEN_CURLY_BRACE=124;
 148   
     public static final int OPEN_SQUARE_BRACKET=125;
 149   
     public static final int OPTIONAL=126;
 150   
     public static final int OR=127;
 151   
     public static final int ORDER=128;
 152   
     public static final int ORDER_BY=129;
 153   
     public static final int ORDER_CONDITION=130;
 154   
     public static final int PATH=131;
 155   
     public static final int PATH_NEGATED=132;
 156   
     public static final int PATH_PRIMARY=133;
 157   
     public static final int PATH_SEQUENCE=134;
 158   
     public static final int PIPE=135;
 159   
     public static final int PLUS=136;
 160   
     public static final int PNAME_LN=137;
 161   
     public static final int PNAME_NS=138;
 162   
     public static final int PN_CHARS=139;
 163   
     public static final int PN_CHARS_BASE=140;
 164   
     public static final int PN_CHARS_U=141;
 165   
     public static final int PN_LOCAL=142;
 166   
     public static final int PN_PREFIX=143;
 167   
     public static final int PREDICATE=144;
 168   
     public static final int PREFIX=145;
 169   
     public static final int PROLOGUE=146;
 170   
     public static final int QUERY=147;
 171   
     public static final int QUESTION_MARK=148;
 172   
     public static final int RAND=149;
 173   
     public static final int REDUCED=150;
 174   
     public static final int REFERENCE=151;
 175   
     public static final int REGEX=152;
 176   
     public static final int REPLACE=153;
 177   
     public static final int ROUND=154;
 178   
     public static final int SAMETERM=155;
 179   
     public static final int SAMPLE=156;
 180   
     public static final int SECONDS=157;
 181   
     public static final int SELECT=158;
 182   
     public static final int SELECT_CLAUSE=159;
 183   
     public static final int SEMICOLON=160;
 184   
     public static final int SEPARATOR=161;
 185   
     public static final int SERVICE=162;
 186   
     public static final int SHA1=163;
 187   
     public static final int SHA224=164;
 188   
     public static final int SHA256=165;
 189   
     public static final int SHA384=166;
 190   
     public static final int SHA512=167;
 191   
     public static final int SIGN=168;
 192   
     public static final int SILENT=169;
 193   
     public static final int STR=170;
 194   
     public static final int STRAFTER=171;
 195   
     public static final int STRBEFORE=172;
 196   
     public static final int STRDT=173;
 197   
     public static final int STRENDS=174;
 198   
     public static final int STRING_LITERAL1=175;
 199   
     public static final int STRING_LITERAL2=176;
 200   
     public static final int STRING_LITERAL_LONG1=177;
 201   
     public static final int STRING_LITERAL_LONG2=178;
 202   
     public static final int STRLANG=179;
 203   
     public static final int STRLEN=180;
 204   
     public static final int STRSTARTS=181;
 205   
     public static final int SUBJECT=182;
 206   
     public static final int SUBSELECT=183;
 207   
     public static final int SUBSTR=184;
 208   
     public static final int SUM=185;
 209   
     public static final int TIMEZONE=186;
 210   
     public static final int TO=187;
 211   
     public static final int TRIPLES_BLOCK=188;
 212   
     public static final int TRIPLES_NODE=189;
 213   
     public static final int TRIPLES_SAME_SUBJECT=190;
 214   
     public static final int TRIPLES_TEMPLATE=191;
 215   
     public static final int TRUE=192;
 216   
     public static final int TZ=193;
 217   
     public static final int UCASE=194;
 218   
     public static final int UNARY=195;
 219   
     public static final int UNDEF=196;
 220   
     public static final int UNION=197;
 221   
     public static final int UPDATE=198;
 222   
     public static final int URI=199;
 223   
     public static final int USING=200;
 224   
     public static final int VAR=201;
 225   
     public static final int VAR1=202;
 226   
     public static final int VAR2=203;
 227   
     public static final int VARNAME=204;
 228   
     public static final int WHERE=205;
 229   
     public static final int WHERE_CLAUSE=206;
 230   
     public static final int WITH=207;
 231   
     public static final int WS=208;
 232   
     public static final int YEAR=209;
 233   
 
 234   
     // delegates
 235   
     public Parser[] getDelegates() {
 236  0 
         return new Parser[] {};
 237   
     }
 238   
 
 239   
     // delegators
 240   
 
 241   
 
 242   
     public SparqlParser(TokenStream input) {
 243  1898 
         this(input, new RecognizerSharedState());
 244  1898 
     }
 245   
     public SparqlParser(TokenStream input, RecognizerSharedState state) {
 246  1898 
         super(input, state);
 247  1898 
     }
 248   
 
 249  1898 
 protected TreeAdaptor adaptor = new CommonTreeAdaptor();
 250   
 
 251   
 public void setTreeAdaptor(TreeAdaptor adaptor) {
 252  0 
     this.adaptor = adaptor;
 253  0 
 }
 254   
 public TreeAdaptor getTreeAdaptor() {
 255  0 
     return adaptor;
 256   
 }
 257  1 
     public String[] getTokenNames() { return SparqlParser.tokenNames; }
 258  0 
     public String getGrammarFileName() { return "com\\googlecode\\sparkleg\\Sparql.g"; }
 259   
 
 260   
 
 261  1898 
     public static class query_return extends ParserRuleReturnScope {
 262   
         Object tree;
 263  1898 
         public Object getTree() { return tree; }
 264   
     };
 265   
 
 266   
 
 267   
     // $ANTLR start "query"
 268   
     // com\\googlecode\\sparkleg\\Sparql.g:76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );
 269   
     public final SparqlParser.query_return query() throws RecognitionException {
 270  1898 
         SparqlParser.query_return retval = new SparqlParser.query_return();
 271  1898 
         retval.start = input.LT(1);
 272   
 
 273   
 
 274  1898 
         Object root_0 = null;
 275   
 
 276  1898 
         Token EOF7=null;
 277  1898 
         Token SEMICOLON9=null;
 278  1898 
         Token EOF11=null;
 279  1898 
         SparqlParser.prologue_return prologue1 =null;
 280   
 
 281  1898 
         SparqlParser.selectQuery_return selectQuery2 =null;
 282   
 
 283  1898 
         SparqlParser.constructQuery_return constructQuery3 =null;
 284   
 
 285  1898 
         SparqlParser.describeQuery_return describeQuery4 =null;
 286   
 
 287  1898 
         SparqlParser.askQuery_return askQuery5 =null;
 288   
 
 289  1898 
         SparqlParser.bindingsClause_return bindingsClause6 =null;
 290   
 
 291  1898 
         SparqlParser.update_return update8 =null;
 292   
 
 293  1898 
         SparqlParser.update_return update10 =null;
 294   
 
 295   
 
 296  1898 
         Object EOF7_tree=null;
 297  1898 
         Object SEMICOLON9_tree=null;
 298  1898 
         Object EOF11_tree=null;
 299  1898 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 300  1898 
         RewriteRuleTokenStream stream_EOF=new RewriteRuleTokenStream(adaptor,"token EOF");
 301  1898 
         RewriteRuleSubtreeStream stream_update=new RewriteRuleSubtreeStream(adaptor,"rule update");
 302  1898 
         RewriteRuleSubtreeStream stream_describeQuery=new RewriteRuleSubtreeStream(adaptor,"rule describeQuery");
 303  1898 
         RewriteRuleSubtreeStream stream_bindingsClause=new RewriteRuleSubtreeStream(adaptor,"rule bindingsClause");
 304  1898 
         RewriteRuleSubtreeStream stream_constructQuery=new RewriteRuleSubtreeStream(adaptor,"rule constructQuery");
 305  1898 
         RewriteRuleSubtreeStream stream_askQuery=new RewriteRuleSubtreeStream(adaptor,"rule askQuery");
 306  1898 
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 307  1898 
         RewriteRuleSubtreeStream stream_selectQuery=new RewriteRuleSubtreeStream(adaptor,"rule selectQuery");
 308   
         try {
 309   
             // com\\googlecode\\sparkleg\\Sparql.g:77:5: ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) )
 310  1898 
             int alt4=2;
 311  1898 
             alt4 = dfa4.predict(input);
 312  1898 
             switch (alt4) {
 313   
                 case 1 :
 314   
                     // com\\googlecode\\sparkleg\\Sparql.g:77:7: prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF
 315   
                     {
 316  1774 
                     pushFollow(FOLLOW_prologue_in_query155);
 317  1774 
                     prologue1=prologue();
 318   
 
 319  1774 
                     state._fsp--;
 320   
 
 321  1774 
                     stream_prologue.add(prologue1.getTree());
 322   
 
 323   
                     // com\\googlecode\\sparkleg\\Sparql.g:77:16: ( selectQuery | constructQuery | describeQuery | askQuery )
 324  1774 
                     int alt1=4;
 325  1774 
                     switch ( input.LA(1) ) {
 326   
                     case SELECT:
 327   
                         {
 328  1554 
                         alt1=1;
 329   
                         }
 330  1554 
                         break;
 331   
                     case CONSTRUCT:
 332   
                         {
 333  70 
                         alt1=2;
 334   
                         }
 335  70 
                         break;
 336   
                     case DESCRIBE:
 337   
                         {
 338  28 
                         alt1=3;
 339   
                         }
 340  28 
                         break;
 341   
                     case ASK:
 342   
                         {
 343  122 
                         alt1=4;
 344   
                         }
 345  122 
                         break;
 346   
                     default:
 347  0 
                         NoViableAltException nvae =
 348   
                             new NoViableAltException("", 1, 0, input);
 349   
 
 350  0 
                         throw nvae;
 351   
 
 352   
                     }
 353   
 
 354  1774 
                     switch (alt1) {
 355   
                         case 1 :
 356   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:17: selectQuery
 357   
                             {
 358  1554 
                             pushFollow(FOLLOW_selectQuery_in_query158);
 359  1554 
                             selectQuery2=selectQuery();
 360   
 
 361  1554 
                             state._fsp--;
 362   
 
 363  1554 
                             stream_selectQuery.add(selectQuery2.getTree());
 364   
 
 365   
                             }
 366  1554 
                             break;
 367   
                         case 2 :
 368   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:31: constructQuery
 369   
                             {
 370  70 
                             pushFollow(FOLLOW_constructQuery_in_query162);
 371  70 
                             constructQuery3=constructQuery();
 372   
 
 373  70 
                             state._fsp--;
 374   
 
 375  70 
                             stream_constructQuery.add(constructQuery3.getTree());
 376   
 
 377   
                             }
 378  70 
                             break;
 379   
                         case 3 :
 380   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:48: describeQuery
 381   
                             {
 382  28 
                             pushFollow(FOLLOW_describeQuery_in_query166);
 383  28 
                             describeQuery4=describeQuery();
 384   
 
 385  28 
                             state._fsp--;
 386   
 
 387  28 
                             stream_describeQuery.add(describeQuery4.getTree());
 388   
 
 389   
                             }
 390  28 
                             break;
 391   
                         case 4 :
 392   
                             // com\\googlecode\\sparkleg\\Sparql.g:77:64: askQuery
 393   
                             {
 394  122 
                             pushFollow(FOLLOW_askQuery_in_query170);
 395  122 
                             askQuery5=askQuery();
 396   
 
 397  122 
                             state._fsp--;
 398   
 
 399  122 
                             stream_askQuery.add(askQuery5.getTree());
 400   
 
 401   
                             }
 402   
                             break;
 403   
 
 404   
                     }
 405   
 
 406   
 
 407  1774 
                     pushFollow(FOLLOW_bindingsClause_in_query173);
 408  1774 
                     bindingsClause6=bindingsClause();
 409   
 
 410  1774 
                     state._fsp--;
 411   
 
 412  1774 
                     stream_bindingsClause.add(bindingsClause6.getTree());
 413   
 
 414  1774 
                     EOF7=(Token)match(input,EOF,FOLLOW_EOF_in_query175);
 415  1774 
                     stream_EOF.add(EOF7);
 416   
 
 417   
 
 418   
                     // AST REWRITE
 419   
                     // elements: bindingsClause, prologue, askQuery, describeQuery, constructQuery, selectQuery
 420   
                     // token labels:
 421   
                     // rule labels: retval
 422   
                     // token list labels:
 423   
                     // rule list labels:
 424   
                     // wildcard labels:
 425  1774 
                     retval.tree = root_0;
 426  1774 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 427   
 
 428  1774 
                     root_0 = (Object)adaptor.nil();
 429   
                     // 77:93: -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )*
 430   
                     {
 431   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:96: ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* )
 432   
                         {
 433  1774 
                         Object root_1 = (Object)adaptor.nil();
 434  1774 
                         root_1 = (Object)adaptor.becomeRoot(
 435   
                         (Object)adaptor.create(QUERY, "QUERY")
 436   
                         , root_1);
 437   
 
 438  1774 
                         adaptor.addChild(root_1, stream_prologue.nextTree());
 439   
 
 440   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:113: ( selectQuery )*
 441  3328 
                         while ( stream_selectQuery.hasNext() ) {
 442  1554 
                             adaptor.addChild(root_1, stream_selectQuery.nextTree());
 443   
 
 444   
                         }
 445  1774 
                         stream_selectQuery.reset();
 446   
 
 447   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:126: ( constructQuery )*
 448  1844 
                         while ( stream_constructQuery.hasNext() ) {
 449  70 
                             adaptor.addChild(root_1, stream_constructQuery.nextTree());
 450   
 
 451   
                         }
 452  1774 
                         stream_constructQuery.reset();
 453   
 
 454   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:142: ( describeQuery )*
 455  1802 
                         while ( stream_describeQuery.hasNext() ) {
 456  28 
                             adaptor.addChild(root_1, stream_describeQuery.nextTree());
 457   
 
 458   
                         }
 459  1774 
                         stream_describeQuery.reset();
 460   
 
 461   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:157: ( askQuery )*
 462  1896 
                         while ( stream_askQuery.hasNext() ) {
 463  122 
                             adaptor.addChild(root_1, stream_askQuery.nextTree());
 464   
 
 465   
                         }
 466  1774 
                         stream_askQuery.reset();
 467   
 
 468  1774 
                         adaptor.addChild(root_0, root_1);
 469   
                         }
 470   
 
 471   
                         // com\\googlecode\\sparkleg\\Sparql.g:77:168: ( bindingsClause )*
 472  1800 
                         while ( stream_bindingsClause.hasNext() ) {
 473  26 
                             adaptor.addChild(root_0, stream_bindingsClause.nextTree());
 474   
 
 475   
                         }
 476  1774 
                         stream_bindingsClause.reset();
 477   
 
 478   
                     }
 479   
 
 480   
 
 481  1774 
                     retval.tree = root_0;
 482   
 
 483   
                     }
 484  1774 
                     break;
 485   
                 case 2 :
 486   
                     // com\\googlecode\\sparkleg\\Sparql.g:78:7: update ( SEMICOLON ( update )? )* EOF
 487   
                     {
 488  124 
                     pushFollow(FOLLOW_update_in_query206);
 489  124 
                     update8=update();
 490   
 
 491  124 
                     state._fsp--;
 492   
 
 493  124 
                     stream_update.add(update8.getTree());
 494   
 
 495   
                     // com\\googlecode\\sparkleg\\Sparql.g:78:14: ( SEMICOLON ( update )? )*
 496   
                     loop3:
 497   
                     do {
 498  128 
                         int alt3=2;
 499  128 
                         switch ( input.LA(1) ) {
 500   
                         case SEMICOLON:
 501   
                             {
 502  4 
                             alt3=1;
 503   
                             }
 504   
                             break;
 505   
 
 506   
                         }
 507   
 
 508  128 
                         switch (alt3) {
 509   
                             case 1 :
 510   
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:15: SEMICOLON ( update )?
 511   
                                 {
 512  4 
                                 SEMICOLON9=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_query209);
 513  4 
                                 stream_SEMICOLON.add(SEMICOLON9);
 514   
 
 515   
 
 516   
                                 // com\\googlecode\\sparkleg\\Sparql.g:78:25: ( update )?
 517  4 
                                 int alt2=2;
 518  4 
                                 switch ( input.LA(1) ) {
 519   
                                     case ADD:
 520   
                                     case ASK:
 521   
                                     case BASE:
 522   
                                     case CLEAR:
 523   
                                     case CONSTRUCT:
 524   
                                     case COPY:
 525   
                                     case CREATE:
 526   
                                     case DELETE:
 527   
                                     case DESCRIBE:
 528   
                                     case DROP:
 529   
                                     case INSERT:
 530   
                                     case LOAD:
 531   
                                     case MOVE:
 532   
                                     case PREFIX:
 533   
                                     case SELECT:
 534   
                                     case WITH:
 535   
                                         {
 536  4 
                                         alt2=1;
 537   
                                         }
 538   
                                         break;
 539   
                                 }
 540   
 
 541  4 
                                 switch (alt2) {
 542   
                                     case 1 :
 543   
                                         // com\\googlecode\\sparkleg\\Sparql.g:78:25: update
 544   
                                         {
 545  4 
                                         pushFollow(FOLLOW_update_in_query211);
 546  4 
                                         update10=update();
 547   
 
 548  4 
                                         state._fsp--;
 549   
 
 550  4 
                                         stream_update.add(update10.getTree());
 551   
 
 552   
                                         }
 553   
                                         break;
 554   
 
 555   
                                 }
 556   
 
 557   
 
 558   
                                 }
 559  4 
                                 break;
 560   
 
 561   
                             default :
 562  124 
                                 break loop3;
 563   
                         }
 564  4 
                     } while (true);
 565   
 
 566   
 
 567  124 
                     EOF11=(Token)match(input,EOF,FOLLOW_EOF_in_query216);
 568  124 
                     stream_EOF.add(EOF11);
 569   
 
 570   
 
 571   
                     // AST REWRITE
 572   
                     // elements: update
 573   
                     // token labels:
 574   
                     // rule labels: retval
 575   
                     // token list labels:
 576   
                     // rule list labels:
 577   
                     // wildcard labels:
 578  124 
                     retval.tree = root_0;
 579  124 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 580   
 
 581  124 
                     root_0 = (Object)adaptor.nil();
 582   
                     // 78:39: -> ^( UPDATE ( update )+ )
 583   
                     {
 584   
                         // com\\googlecode\\sparkleg\\Sparql.g:78:42: ^( UPDATE ( update )+ )
 585   
                         {
 586  124 
                         Object root_1 = (Object)adaptor.nil();
 587  124 
                         root_1 = (Object)adaptor.becomeRoot(
 588   
                         (Object)adaptor.create(UPDATE, "UPDATE")
 589   
                         , root_1);
 590   
 
 591  124 
                         if ( !(stream_update.hasNext()) ) {
 592  0 
                             throw new RewriteEarlyExitException();
 593   
                         }
 594  252 
                         while ( stream_update.hasNext() ) {
 595  128 
                             adaptor.addChild(root_1, stream_update.nextTree());
 596   
 
 597   
                         }
 598  124 
                         stream_update.reset();
 599   
 
 600  124 
                         adaptor.addChild(root_0, root_1);
 601   
                         }
 602   
 
 603   
                     }
 604   
 
 605   
 
 606  124 
                     retval.tree = root_0;
 607   
 
 608   
                     }
 609   
                     break;
 610   
 
 611   
             }
 612  1898 
             retval.stop = input.LT(-1);
 613   
 
 614   
 
 615  1898 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 616  1898 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 617   
 
 618   
         }
 619  0 
         catch (RecognitionException re) {
 620  0 
             reportError(re);
 621  0 
             recover(input,re);
 622  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 623   
 
 624   
         }
 625   
 
 626  0 
         finally {
 627   
                 // do for sure before leaving
 628  1898 
         }
 629  1898 
         return retval;
 630   
     }
 631   
     // $ANTLR end "query"
 632   
 
 633   
 
 634  1902 
     public static class prologue_return extends ParserRuleReturnScope {
 635   
         Object tree;
 636  1902 
         public Object getTree() { return tree; }
 637   
     };
 638   
 
 639   
 
 640   
     // $ANTLR start "prologue"
 641   
     // com\\googlecode\\sparkleg\\Sparql.g:81:1: prologue : ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) ;
 642   
     public final SparqlParser.prologue_return prologue() throws RecognitionException {
 643  1902 
         SparqlParser.prologue_return retval = new SparqlParser.prologue_return();
 644  1902 
         retval.start = input.LT(1);
 645   
 
 646   
 
 647  1902 
         Object root_0 = null;
 648   
 
 649  1902 
         SparqlParser.baseDecl_return baseDecl12 =null;
 650   
 
 651  1902 
         SparqlParser.prefixDecl_return prefixDecl13 =null;
 652   
 
 653   
 
 654  1902 
         RewriteRuleSubtreeStream stream_prefixDecl=new RewriteRuleSubtreeStream(adaptor,"rule prefixDecl");
 655  1902 
         RewriteRuleSubtreeStream stream_baseDecl=new RewriteRuleSubtreeStream(adaptor,"rule baseDecl");
 656   
         try {
 657   
             // com\\googlecode\\sparkleg\\Sparql.g:83:5: ( ( baseDecl | prefixDecl )* -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* ) )
 658   
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 659   
             {
 660   
             // com\\googlecode\\sparkleg\\Sparql.g:83:7: ( baseDecl | prefixDecl )*
 661   
             loop5:
 662   
             do {
 663  4746 
                 int alt5=3;
 664  4746 
                 switch ( input.LA(1) ) {
 665   
                 case BASE:
 666   
                     {
 667  62 
                     alt5=1;
 668   
                     }
 669  62 
                     break;
 670   
                 case PREFIX:
 671   
                     {
 672  2782 
                     alt5=2;
 673   
                     }
 674   
                     break;
 675   
 
 676   
                 }
 677   
 
 678  4746 
                 switch (alt5) {
 679   
                     case 1 :
 680   
                         // com\\googlecode\\sparkleg\\Sparql.g:83:8: baseDecl
 681   
                         {
 682  62 
                         pushFollow(FOLLOW_baseDecl_in_prologue249);
 683  62 
                         baseDecl12=baseDecl();
 684   
 
 685  62 
                         state._fsp--;
 686   
 
 687  62 
                         stream_baseDecl.add(baseDecl12.getTree());
 688   
 
 689   
                         }
 690  62 
                         break;
 691   
                     case 2 :
 692   
                         // com\\googlecode\\sparkleg\\Sparql.g:83:19: prefixDecl
 693   
                         {
 694  2782 
                         pushFollow(FOLLOW_prefixDecl_in_prologue253);
 695  2782 
                         prefixDecl13=prefixDecl();
 696   
 
 697  2782 
                         state._fsp--;
 698   
 
 699  2782 
                         stream_prefixDecl.add(prefixDecl13.getTree());
 700   
 
 701   
                         }
 702  2782 
                         break;
 703   
 
 704   
                     default :
 705  1902 
                         break loop5;
 706   
                 }
 707  2844 
             } while (true);
 708   
 
 709   
 
 710   
             // AST REWRITE
 711   
             // elements: baseDecl, prefixDecl
 712   
             // token labels:
 713   
             // rule labels: retval
 714   
             // token list labels:
 715   
             // rule list labels:
 716   
             // wildcard labels:
 717  1902 
             retval.tree = root_0;
 718  1902 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 719   
 
 720  1902 
             root_0 = (Object)adaptor.nil();
 721   
             // 83:32: -> ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 722   
             {
 723   
                 // com\\googlecode\\sparkleg\\Sparql.g:83:35: ^( PROLOGUE ( baseDecl )* ( prefixDecl )* )
 724   
                 {
 725  1902 
                 Object root_1 = (Object)adaptor.nil();
 726  1902 
                 root_1 = (Object)adaptor.becomeRoot(
 727   
                 (Object)adaptor.create(PROLOGUE, "PROLOGUE")
 728   
                 , root_1);
 729   
 
 730   
                 // com\\googlecode\\sparkleg\\Sparql.g:83:46: ( baseDecl )*
 731  1964 
                 while ( stream_baseDecl.hasNext() ) {
 732  62 
                     adaptor.addChild(root_1, stream_baseDecl.nextTree());
 733   
 
 734   
                 }
 735  1902 
                 stream_baseDecl.reset();
 736   
 
 737   
                 // com\\googlecode\\sparkleg\\Sparql.g:83:56: ( prefixDecl )*
 738  4684 
                 while ( stream_prefixDecl.hasNext() ) {
 739  2782 
                     adaptor.addChild(root_1, stream_prefixDecl.nextTree());
 740   
 
 741   
                 }
 742  1902 
                 stream_prefixDecl.reset();
 743   
 
 744  1902 
                 adaptor.addChild(root_0, root_1);
 745   
                 }
 746   
 
 747   
             }
 748   
 
 749   
 
 750  1902 
             retval.tree = root_0;
 751   
 
 752   
             }
 753   
 
 754  1902 
             retval.stop = input.LT(-1);
 755   
 
 756   
 
 757  1902 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 758  1902 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 759   
 
 760   
         }
 761  0 
         catch (RecognitionException re) {
 762  0 
             reportError(re);
 763  0 
             recover(input,re);
 764  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 765   
 
 766   
         }
 767   
 
 768  0 
         finally {
 769   
                 // do for sure before leaving
 770  1902 
         }
 771  1902 
         return retval;
 772   
     }
 773   
     // $ANTLR end "prologue"
 774   
 
 775   
 
 776  62 
     public static class baseDecl_return extends ParserRuleReturnScope {
 777   
         Object tree;
 778  62 
         public Object getTree() { return tree; }
 779   
     };
 780   
 
 781   
 
 782   
     // $ANTLR start "baseDecl"
 783   
     // com\\googlecode\\sparkleg\\Sparql.g:86:1: baseDecl : BASE IRI_REF -> ^( BASE IRI_REF ) ;
 784   
     public final SparqlParser.baseDecl_return baseDecl() throws RecognitionException {
 785  62 
         SparqlParser.baseDecl_return retval = new SparqlParser.baseDecl_return();
 786  62 
         retval.start = input.LT(1);
 787   
 
 788   
 
 789  62 
         Object root_0 = null;
 790   
 
 791  62 
         Token BASE14=null;
 792  62 
         Token IRI_REF15=null;
 793   
 
 794  62 
         Object BASE14_tree=null;
 795  62 
         Object IRI_REF15_tree=null;
 796  62 
         RewriteRuleTokenStream stream_BASE=new RewriteRuleTokenStream(adaptor,"token BASE");
 797  62 
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 798   
 
 799   
         try {
 800   
             // com\\googlecode\\sparkleg\\Sparql.g:87:5: ( BASE IRI_REF -> ^( BASE IRI_REF ) )
 801   
             // com\\googlecode\\sparkleg\\Sparql.g:87:7: BASE IRI_REF
 802   
             {
 803  62 
             BASE14=(Token)match(input,BASE,FOLLOW_BASE_in_baseDecl284);
 804  62 
             stream_BASE.add(BASE14);
 805   
 
 806   
 
 807  62 
             IRI_REF15=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_baseDecl286);
 808  62 
             stream_IRI_REF.add(IRI_REF15);
 809   
 
 810   
 
 811   
             // AST REWRITE
 812   
             // elements: IRI_REF, BASE
 813   
             // token labels:
 814   
             // rule labels: retval
 815   
             // token list labels:
 816   
             // rule list labels:
 817   
             // wildcard labels:
 818  62 
             retval.tree = root_0;
 819  62 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 820   
 
 821  62 
             root_0 = (Object)adaptor.nil();
 822   
             // 87:20: -> ^( BASE IRI_REF )
 823   
             {
 824   
                 // com\\googlecode\\sparkleg\\Sparql.g:87:23: ^( BASE IRI_REF )
 825   
                 {
 826  62 
                 Object root_1 = (Object)adaptor.nil();
 827  62 
                 root_1 = (Object)adaptor.becomeRoot(
 828   
                 stream_BASE.nextNode()
 829   
                 , root_1);
 830   
 
 831  62 
                 adaptor.addChild(root_1,
 832   
                 stream_IRI_REF.nextNode()
 833   
                 );
 834   
 
 835  62 
                 adaptor.addChild(root_0, root_1);
 836   
                 }
 837   
 
 838   
             }
 839   
 
 840   
 
 841  62 
             retval.tree = root_0;
 842   
 
 843   
             }
 844   
 
 845  62 
             retval.stop = input.LT(-1);
 846   
 
 847   
 
 848  62 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 849  62 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 850   
 
 851   
         }
 852  0 
         catch (RecognitionException re) {
 853  0 
             reportError(re);
 854  0 
             recover(input,re);
 855  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 856   
 
 857   
         }
 858   
 
 859  0 
         finally {
 860   
                 // do for sure before leaving
 861  62 
         }
 862  62 
         return retval;
 863   
     }
 864   
     // $ANTLR end "baseDecl"
 865   
 
 866   
 
 867  2782 
     public static class prefixDecl_return extends ParserRuleReturnScope {
 868   
         Object tree;
 869  2782 
         public Object getTree() { return tree; }
 870   
     };
 871   
 
 872   
 
 873   
     // $ANTLR start "prefixDecl"
 874   
     // com\\googlecode\\sparkleg\\Sparql.g:90:1: prefixDecl : PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) ;
 875   
     public final SparqlParser.prefixDecl_return prefixDecl() throws RecognitionException {
 876  2782 
         SparqlParser.prefixDecl_return retval = new SparqlParser.prefixDecl_return();
 877  2782 
         retval.start = input.LT(1);
 878   
 
 879   
 
 880  2782 
         Object root_0 = null;
 881   
 
 882  2782 
         Token PREFIX16=null;
 883  2782 
         Token PNAME_NS17=null;
 884  2782 
         Token IRI_REF18=null;
 885   
 
 886  2782 
         Object PREFIX16_tree=null;
 887  2782 
         Object PNAME_NS17_tree=null;
 888  2782 
         Object IRI_REF18_tree=null;
 889  2782 
         RewriteRuleTokenStream stream_PREFIX=new RewriteRuleTokenStream(adaptor,"token PREFIX");
 890  2782 
         RewriteRuleTokenStream stream_PNAME_NS=new RewriteRuleTokenStream(adaptor,"token PNAME_NS");
 891  2782 
         RewriteRuleTokenStream stream_IRI_REF=new RewriteRuleTokenStream(adaptor,"token IRI_REF");
 892   
 
 893   
         try {
 894   
             // com\\googlecode\\sparkleg\\Sparql.g:91:5: ( PREFIX PNAME_NS IRI_REF -> ^( PREFIX PNAME_NS IRI_REF ) )
 895   
             // com\\googlecode\\sparkleg\\Sparql.g:91:7: PREFIX PNAME_NS IRI_REF
 896   
             {
 897  2782 
             PREFIX16=(Token)match(input,PREFIX,FOLLOW_PREFIX_in_prefixDecl312);
 898  2782 
             stream_PREFIX.add(PREFIX16);
 899   
 
 900   
 
 901  2782 
             PNAME_NS17=(Token)match(input,PNAME_NS,FOLLOW_PNAME_NS_in_prefixDecl314);
 902  2782 
             stream_PNAME_NS.add(PNAME_NS17);
 903   
 
 904   
 
 905  2782 
             IRI_REF18=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_prefixDecl316);
 906  2782 
             stream_IRI_REF.add(IRI_REF18);
 907   
 
 908   
 
 909   
             // AST REWRITE
 910   
             // elements: PREFIX, IRI_REF, PNAME_NS
 911   
             // token labels:
 912   
             // rule labels: retval
 913   
             // token list labels:
 914   
             // rule list labels:
 915   
             // wildcard labels:
 916  2782 
             retval.tree = root_0;
 917  2782 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 918   
 
 919  2782 
             root_0 = (Object)adaptor.nil();
 920   
             // 91:31: -> ^( PREFIX PNAME_NS IRI_REF )
 921   
             {
 922   
                 // com\\googlecode\\sparkleg\\Sparql.g:91:34: ^( PREFIX PNAME_NS IRI_REF )
 923   
                 {
 924  2782 
                 Object root_1 = (Object)adaptor.nil();
 925  2782 
                 root_1 = (Object)adaptor.becomeRoot(
 926   
                 stream_PREFIX.nextNode()
 927   
                 , root_1);
 928   
 
 929  2782 
                 adaptor.addChild(root_1,
 930   
                 stream_PNAME_NS.nextNode()
 931   
                 );
 932   
 
 933  2782 
                 adaptor.addChild(root_1,
 934   
                 stream_IRI_REF.nextNode()
 935   
                 );
 936   
 
 937  2782 
                 adaptor.addChild(root_0, root_1);
 938   
                 }
 939   
 
 940   
             }
 941   
 
 942   
 
 943  2782 
             retval.tree = root_0;
 944   
 
 945   
             }
 946   
 
 947  2782 
             retval.stop = input.LT(-1);
 948   
 
 949   
 
 950  2782 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 951  2782 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 952   
 
 953   
         }
 954  0 
         catch (RecognitionException re) {
 955  0 
             reportError(re);
 956  0 
             recover(input,re);
 957  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 958   
 
 959   
         }
 960   
 
 961  0 
         finally {
 962   
                 // do for sure before leaving
 963  2782 
         }
 964  2782 
         return retval;
 965   
     }
 966   
     // $ANTLR end "prefixDecl"
 967   
 
 968   
 
 969  1554 
     public static class selectQuery_return extends ParserRuleReturnScope {
 970   
         Object tree;
 971  1554 
         public Object getTree() { return tree; }
 972   
     };
 973   
 
 974   
 
 975   
     // $ANTLR start "selectQuery"
 976   
     // com\\googlecode\\sparkleg\\Sparql.g:94:1: selectQuery : selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) ;
 977   
     public final SparqlParser.selectQuery_return selectQuery() throws RecognitionException {
 978  1554 
         SparqlParser.selectQuery_return retval = new SparqlParser.selectQuery_return();
 979  1554 
         retval.start = input.LT(1);
 980   
 
 981   
 
 982  1554 
         Object root_0 = null;
 983   
 
 984  1554 
         SparqlParser.selectClause_return selectClause19 =null;
 985   
 
 986  1554 
         SparqlParser.datasetClause_return datasetClause20 =null;
 987   
 
 988  1554 
         SparqlParser.whereClause_return whereClause21 =null;
 989   
 
 990  1554 
         SparqlParser.solutionModifier_return solutionModifier22 =null;
 991   
 
 992   
 
 993  1554 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 994  1554 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 995  1554 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 996  1554 
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 997   
         try {
 998   
             // com\\googlecode\\sparkleg\\Sparql.g:95:5: ( selectClause ( datasetClause )* whereClause solutionModifier -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* ) )
 999   
             // com\\googlecode\\sparkleg\\Sparql.g:95:7: selectClause ( datasetClause )* whereClause solutionModifier
 1000   
             {
 1001  1554 
             pushFollow(FOLLOW_selectClause_in_selectQuery343);
 1002  1554 
             selectClause19=selectClause();
 1003   
 
 1004  1554 
             state._fsp--;
 1005   
 
 1006  1554 
             stream_selectClause.add(selectClause19.getTree());
 1007   
 
 1008   
             // com\\googlecode\\sparkleg\\Sparql.g:95:20: ( datasetClause )*
 1009   
             loop6:
 1010   
             do {
 1011  1712 
                 int alt6=2;
 1012  1712 
                 switch ( input.LA(1) ) {
 1013   
                 case FROM:
 1014   
                     {
 1015  158 
                     alt6=1;
 1016   
                     }
 1017   
                     break;
 1018   
 
 1019   
                 }
 1020   
 
 1021  1712 
                 switch (alt6) {
 1022   
                     case 1 :
 1023   
                         // com\\googlecode\\sparkleg\\Sparql.g:95:20: datasetClause
 1024   
                         {
 1025  158 
                         pushFollow(FOLLOW_datasetClause_in_selectQuery345);
 1026  158 
                         datasetClause20=datasetClause();
 1027   
 
 1028  158 
                         state._fsp--;
 1029   
 
 1030  158 
                         stream_datasetClause.add(datasetClause20.getTree());
 1031   
 
 1032   
                         }
 1033  158 
                         break;
 1034   
 
 1035   
                     default :
 1036  1554 
                         break loop6;
 1037   
                 }
 1038  158 
             } while (true);
 1039   
 
 1040   
 
 1041  1554 
             pushFollow(FOLLOW_whereClause_in_selectQuery348);
 1042  1554 
             whereClause21=whereClause();
 1043   
 
 1044  1554 
             state._fsp--;
 1045   
 
 1046  1554 
             stream_whereClause.add(whereClause21.getTree());
 1047   
 
 1048  1554 
             pushFollow(FOLLOW_solutionModifier_in_selectQuery350);
 1049  1554 
             solutionModifier22=solutionModifier();
 1050   
 
 1051  1554 
             state._fsp--;
 1052   
 
 1053  1554 
             stream_solutionModifier.add(solutionModifier22.getTree());
 1054   
 
 1055   
             // AST REWRITE
 1056   
             // elements: selectClause, solutionModifier, whereClause, datasetClause
 1057   
             // token labels:
 1058   
             // rule labels: retval
 1059   
             // token list labels:
 1060   
             // rule list labels:
 1061   
             // wildcard labels:
 1062  1554 
             retval.tree = root_0;
 1063  1554 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1064   
 
 1065  1554 
             root_0 = (Object)adaptor.nil();
 1066   
             // 95:64: -> ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1067   
             {
 1068   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:67: ^( SELECT selectClause ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1069   
                 {
 1070  1554 
                 Object root_1 = (Object)adaptor.nil();
 1071  1554 
                 root_1 = (Object)adaptor.becomeRoot(
 1072   
                 (Object)adaptor.create(SELECT, "SELECT")
 1073   
                 , root_1);
 1074   
 
 1075  1554 
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1076   
 
 1077   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:89: ( datasetClause )*
 1078  1712 
                 while ( stream_datasetClause.hasNext() ) {
 1079  158 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1080   
 
 1081   
                 }
 1082  1554 
                 stream_datasetClause.reset();
 1083   
 
 1084   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:104: ( whereClause )*
 1085  3108 
                 while ( stream_whereClause.hasNext() ) {
 1086  1554 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1087   
 
 1088   
                 }
 1089  1554 
                 stream_whereClause.reset();
 1090   
 
 1091   
                 // com\\googlecode\\sparkleg\\Sparql.g:95:117: ( solutionModifier )*
 1092  1742 
                 while ( stream_solutionModifier.hasNext() ) {
 1093  188 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1094   
 
 1095   
                 }
 1096  1554 
                 stream_solutionModifier.reset();
 1097   
 
 1098  1554 
                 adaptor.addChild(root_0, root_1);
 1099   
                 }
 1100   
 
 1101   
             }
 1102   
 
 1103   
 
 1104  1554 
             retval.tree = root_0;
 1105   
 
 1106   
             }
 1107   
 
 1108  1554 
             retval.stop = input.LT(-1);
 1109   
 
 1110   
 
 1111  1554 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1112  1554 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1113   
 
 1114   
         }
 1115  0 
         catch (RecognitionException re) {
 1116  0 
             reportError(re);
 1117  0 
             recover(input,re);
 1118  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1119   
 
 1120   
         }
 1121   
 
 1122  0 
         finally {
 1123   
                 // do for sure before leaving
 1124  1554 
         }
 1125  1554 
         return retval;
 1126   
     }
 1127   
     // $ANTLR end "selectQuery"
 1128   
 
 1129   
 
 1130  46 
     public static class subSelect_return extends ParserRuleReturnScope {
 1131   
         Object tree;
 1132  46 
         public Object getTree() { return tree; }
 1133   
     };
 1134   
 
 1135   
 
 1136   
     // $ANTLR start "subSelect"
 1137   
     // com\\googlecode\\sparkleg\\Sparql.g:98:1: subSelect : selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) ;
 1138   
     public final SparqlParser.subSelect_return subSelect() throws RecognitionException {
 1139  46 
         SparqlParser.subSelect_return retval = new SparqlParser.subSelect_return();
 1140  46 
         retval.start = input.LT(1);
 1141   
 
 1142   
 
 1143  46 
         Object root_0 = null;
 1144   
 
 1145  46 
         SparqlParser.selectClause_return selectClause23 =null;
 1146   
 
 1147  46 
         SparqlParser.whereClause_return whereClause24 =null;
 1148   
 
 1149  46 
         SparqlParser.solutionModifier_return solutionModifier25 =null;
 1150   
 
 1151   
 
 1152  46 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1153  46 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1154  46 
         RewriteRuleSubtreeStream stream_selectClause=new RewriteRuleSubtreeStream(adaptor,"rule selectClause");
 1155   
         try {
 1156   
             // com\\googlecode\\sparkleg\\Sparql.g:99:5: ( selectClause whereClause solutionModifier -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* ) )
 1157   
             // com\\googlecode\\sparkleg\\Sparql.g:99:7: selectClause whereClause solutionModifier
 1158   
             {
 1159  46 
             pushFollow(FOLLOW_selectClause_in_subSelect384);
 1160  46 
             selectClause23=selectClause();
 1161   
 
 1162  46 
             state._fsp--;
 1163   
 
 1164  46 
             stream_selectClause.add(selectClause23.getTree());
 1165   
 
 1166  46 
             pushFollow(FOLLOW_whereClause_in_subSelect386);
 1167  46 
             whereClause24=whereClause();
 1168   
 
 1169  46 
             state._fsp--;
 1170   
 
 1171  46 
             stream_whereClause.add(whereClause24.getTree());
 1172   
 
 1173  46 
             pushFollow(FOLLOW_solutionModifier_in_subSelect388);
 1174  46 
             solutionModifier25=solutionModifier();
 1175   
 
 1176  46 
             state._fsp--;
 1177   
 
 1178  46 
             stream_solutionModifier.add(solutionModifier25.getTree());
 1179   
 
 1180   
             // AST REWRITE
 1181   
             // elements: solutionModifier, selectClause, whereClause
 1182   
             // token labels:
 1183   
             // rule labels: retval
 1184   
             // token list labels:
 1185   
             // rule list labels:
 1186   
             // wildcard labels:
 1187  46 
             retval.tree = root_0;
 1188  46 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1189   
 
 1190  46 
             root_0 = (Object)adaptor.nil();
 1191   
             // 99:49: -> ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1192   
             {
 1193   
                 // com\\googlecode\\sparkleg\\Sparql.g:99:52: ^( SUBSELECT selectClause ( whereClause )* ( solutionModifier )* )
 1194   
                 {
 1195  46 
                 Object root_1 = (Object)adaptor.nil();
 1196  46 
                 root_1 = (Object)adaptor.becomeRoot(
 1197   
                 (Object)adaptor.create(SUBSELECT, "SUBSELECT")
 1198   
                 , root_1);
 1199   
 
 1200  46 
                 adaptor.addChild(root_1, stream_selectClause.nextTree());
 1201   
 
 1202   
                 // com\\googlecode\\sparkleg\\Sparql.g:99:77: ( whereClause )*
 1203  92 
                 while ( stream_whereClause.hasNext() ) {
 1204  46 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 1205   
 
 1206   
                 }
 1207  46 
                 stream_whereClause.reset();
 1208   
 
 1209   
                 // com\\googlecode\\sparkleg\\Sparql.g:99:90: ( solutionModifier )*
 1210  56 
                 while ( stream_solutionModifier.hasNext() ) {
 1211  10 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 1212   
 
 1213   
                 }
 1214  46 
                 stream_solutionModifier.reset();
 1215   
 
 1216  46 
                 adaptor.addChild(root_0, root_1);
 1217   
                 }
 1218   
 
 1219   
             }
 1220   
 
 1221   
 
 1222  46 
             retval.tree = root_0;
 1223   
 
 1224   
             }
 1225   
 
 1226  46 
             retval.stop = input.LT(-1);
 1227   
 
 1228   
 
 1229  46 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1230  46 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1231   
 
 1232   
         }
 1233  0 
         catch (RecognitionException re) {
 1234  0 
             reportError(re);
 1235  0 
             recover(input,re);
 1236  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1237   
 
 1238   
         }
 1239   
 
 1240  0 
         finally {
 1241   
                 // do for sure before leaving
 1242  46 
         }
 1243  46 
         return retval;
 1244   
     }
 1245   
     // $ANTLR end "subSelect"
 1246   
 
 1247   
 
 1248  1600 
     public static class selectClause_return extends ParserRuleReturnScope {
 1249   
         Object tree;
 1250  1600 
         public Object getTree() { return tree; }
 1251   
     };
 1252   
 
 1253   
 
 1254   
     // $ANTLR start "selectClause"
 1255   
     // com\\googlecode\\sparkleg\\Sparql.g:102:1: selectClause : ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) );
 1256   
     public final SparqlParser.selectClause_return selectClause() throws RecognitionException {
 1257  1600 
         SparqlParser.selectClause_return retval = new SparqlParser.selectClause_return();
 1258  1600 
         retval.start = input.LT(1);
 1259   
 
 1260   
 
 1261  1600 
         Object root_0 = null;
 1262   
 
 1263  1600 
         Token SELECT26=null;
 1264  1600 
         Token DISTINCT27=null;
 1265  1600 
         Token REDUCED28=null;
 1266  1600 
         Token ASTERISK29=null;
 1267  1600 
         Token SELECT30=null;
 1268  1600 
         Token DISTINCT31=null;
 1269  1600 
         Token REDUCED32=null;
 1270  1600 
         List list_v=null;
 1271  1600 
         RuleReturnScope v = null;
 1272  1600 
         Object SELECT26_tree=null;
 1273  1600 
         Object DISTINCT27_tree=null;
 1274  1600 
         Object REDUCED28_tree=null;
 1275  1600 
         Object ASTERISK29_tree=null;
 1276  1600 
         Object SELECT30_tree=null;
 1277  1600 
         Object DISTINCT31_tree=null;
 1278  1600 
         Object REDUCED32_tree=null;
 1279  1600 
         RewriteRuleTokenStream stream_SELECT=new RewriteRuleTokenStream(adaptor,"token SELECT");
 1280  1600 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 1281  1600 
         RewriteRuleTokenStream stream_REDUCED=new RewriteRuleTokenStream(adaptor,"token REDUCED");
 1282  1600 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 1283  1600 
         RewriteRuleSubtreeStream stream_selectVariables=new RewriteRuleSubtreeStream(adaptor,"rule selectVariables");
 1284   
         try {
 1285   
             // com\\googlecode\\sparkleg\\Sparql.g:103:5: ( SELECT ( DISTINCT | REDUCED )? ASTERISK -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK ) | SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+ -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* ) )
 1286  1600 
             int alt10=2;
 1287  1600 
             switch ( input.LA(1) ) {
 1288   
             case SELECT:
 1289   
                 {
 1290  1600 
                 switch ( input.LA(2) ) {
 1291   
                 case DISTINCT:
 1292   
                     {
 1293  44 
                     switch ( input.LA(3) ) {
 1294   
                     case ASTERISK:
 1295   
                         {
 1296  2 
                         alt10=1;
 1297   
                         }
 1298  2 
                         break;
 1299   
                     case OPEN_BRACE:
 1300   
                     case VAR1:
 1301   
                     case VAR2:
 1302   
                         {
 1303  42 
                         alt10=2;
 1304   
                         }
 1305  42 
                         break;
 1306   
                     default:
 1307  0 
                         NoViableAltException nvae =
 1308   
                             new NoViableAltException("", 10, 2, input);
 1309   
 
 1310  0 
                         throw nvae;
 1311   
 
 1312   
                     }
 1313   
 
 1314   
                     }
 1315  44 
                     break;
 1316   
                 case REDUCED:
 1317   
                     {
 1318  14 
                     switch ( input.LA(3) ) {
 1319   
                     case ASTERISK:
 1320   
                         {
 1321  4 
                         alt10=1;
 1322   
                         }
 1323  4 
                         break;
 1324   
                     case OPEN_BRACE:
 1325   
                     case VAR1:
 1326   
                     case VAR2:
 1327   
                         {
 1328  10 
                         alt10=2;
 1329   
                         }
 1330  10 
                         break;
 1331   
                     default:
 1332  0 
                         NoViableAltException nvae =
 1333   
                             new NoViableAltException("", 10, 3, input);
 1334   
 
 1335  0 
                         throw nvae;
 1336   
 
 1337   
                     }
 1338   
 
 1339   
                     }
 1340  14 
                     break;
 1341   
                 case ASTERISK:
 1342   
                     {
 1343  612 
                     alt10=1;
 1344   
                     }
 1345  612 
                     break;
 1346   
                 case OPEN_BRACE:
 1347   
                 case VAR1:
 1348   
                 case VAR2:
 1349   
                     {
 1350  930 
                     alt10=2;
 1351   
                     }
 1352  930 
                     break;
 1353   
                 default:
 1354  0 
                     NoViableAltException nvae =
 1355   
                         new NoViableAltException("", 10, 1, input);
 1356   
 
 1357  0 
                     throw nvae;
 1358   
 
 1359   
                 }
 1360   
 
 1361   
                 }
 1362  1600 
                 break;
 1363   
             default:
 1364  0 
                 NoViableAltException nvae =
 1365   
                     new NoViableAltException("", 10, 0, input);
 1366   
 
 1367  0 
                 throw nvae;
 1368   
 
 1369   
             }
 1370   
 
 1371  1600 
             switch (alt10) {
 1372   
                 case 1 :
 1373   
                     // com\\googlecode\\sparkleg\\Sparql.g:103:7: SELECT ( DISTINCT | REDUCED )? ASTERISK
 1374   
                     {
 1375  618 
                     SELECT26=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause424);
 1376  618 
                     stream_SELECT.add(SELECT26);
 1377   
 
 1378   
 
 1379   
                     // com\\googlecode\\sparkleg\\Sparql.g:103:14: ( DISTINCT | REDUCED )?
 1380  618 
                     int alt7=3;
 1381  618 
                     switch ( input.LA(1) ) {
 1382   
                         case DISTINCT:
 1383   
                             {
 1384  2 
                             alt7=1;
 1385   
                             }
 1386  2 
                             break;
 1387   
                         case REDUCED:
 1388   
                             {
 1389  4 
                             alt7=2;
 1390   
                             }
 1391   
                             break;
 1392   
                     }
 1393   
 
 1394  618 
                     switch (alt7) {
 1395   
                         case 1 :
 1396   
                             // com\\googlecode\\sparkleg\\Sparql.g:103:15: DISTINCT
 1397   
                             {
 1398  2 
                             DISTINCT27=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause427);
 1399  2 
                             stream_DISTINCT.add(DISTINCT27);
 1400   
 
 1401   
 
 1402   
                             }
 1403  2 
                             break;
 1404   
                         case 2 :
 1405   
                             // com\\googlecode\\sparkleg\\Sparql.g:103:26: REDUCED
 1406   
                             {
 1407  4 
                             REDUCED28=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause431);
 1408  4 
                             stream_REDUCED.add(REDUCED28);
 1409   
 
 1410   
 
 1411   
                             }
 1412   
                             break;
 1413   
 
 1414   
                     }
 1415   
 
 1416   
 
 1417  618 
                     ASTERISK29=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_selectClause435);
 1418  618 
                     stream_ASTERISK.add(ASTERISK29);
 1419   
 
 1420   
 
 1421   
                     // AST REWRITE
 1422   
                     // elements: ASTERISK, REDUCED, DISTINCT
 1423   
                     // token labels:
 1424   
                     // rule labels: retval
 1425   
                     // token list labels:
 1426   
                     // rule list labels:
 1427   
                     // wildcard labels:
 1428  618 
                     retval.tree = root_0;
 1429  618 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1430   
 
 1431  618 
                     root_0 = (Object)adaptor.nil();
 1432   
                     // 103:45: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1433   
                     {
 1434   
                         // com\\googlecode\\sparkleg\\Sparql.g:103:48: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ASTERISK )
 1435   
                         {
 1436  618 
                         Object root_1 = (Object)adaptor.nil();
 1437  618 
                         root_1 = (Object)adaptor.becomeRoot(
 1438   
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1439   
                         , root_1);
 1440   
 
 1441   
                         // com\\googlecode\\sparkleg\\Sparql.g:103:64: ( DISTINCT )*
 1442  620 
                         while ( stream_DISTINCT.hasNext() ) {
 1443  2 
                             adaptor.addChild(root_1,
 1444   
                             stream_DISTINCT.nextNode()
 1445   
                             );
 1446   
 
 1447   
                         }
 1448  618 
                         stream_DISTINCT.reset();
 1449   
 
 1450   
                         // com\\googlecode\\sparkleg\\Sparql.g:103:74: ( REDUCED )*
 1451  622 
                         while ( stream_REDUCED.hasNext() ) {
 1452  4 
                             adaptor.addChild(root_1,
 1453   
                             stream_REDUCED.nextNode()
 1454   
                             );
 1455   
 
 1456   
                         }
 1457  618 
                         stream_REDUCED.reset();
 1458   
 
 1459  618 
                         adaptor.addChild(root_1,
 1460   
                         stream_ASTERISK.nextNode()
 1461   
                         );
 1462   
 
 1463  618 
                         adaptor.addChild(root_0, root_1);
 1464   
                         }
 1465   
 
 1466   
                     }
 1467   
 
 1468   
 
 1469  618 
                     retval.tree = root_0;
 1470   
 
 1471   
                     }
 1472  618 
                     break;
 1473   
                 case 2 :
 1474   
                     // com\\googlecode\\sparkleg\\Sparql.g:104:7: SELECT ( DISTINCT | REDUCED )? (v+= selectVariables )+
 1475   
                     {
 1476  982 
                     SELECT30=(Token)match(input,SELECT,FOLLOW_SELECT_in_selectClause457);
 1477  982 
                     stream_SELECT.add(SELECT30);
 1478   
 
 1479   
 
 1480   
                     // com\\googlecode\\sparkleg\\Sparql.g:104:14: ( DISTINCT | REDUCED )?
 1481  982 
                     int alt8=3;
 1482  982 
                     switch ( input.LA(1) ) {
 1483   
                         case DISTINCT:
 1484   
                             {
 1485  42 
                             alt8=1;
 1486   
                             }
 1487  42 
                             break;
 1488   
                         case REDUCED:
 1489   
                             {
 1490  10 
                             alt8=2;
 1491   
                             }
 1492   
                             break;
 1493   
                     }
 1494   
 
 1495  982 
                     switch (alt8) {
 1496   
                         case 1 :
 1497   
                             // com\\googlecode\\sparkleg\\Sparql.g:104:15: DISTINCT
 1498   
                             {
 1499  42 
                             DISTINCT31=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_selectClause460);
 1500  42 
                             stream_DISTINCT.add(DISTINCT31);
 1501   
 
 1502   
 
 1503   
                             }
 1504  42 
                             break;
 1505   
                         case 2 :
 1506   
                             // com\\googlecode\\sparkleg\\Sparql.g:104:26: REDUCED
 1507   
                             {
 1508  10 
                             REDUCED32=(Token)match(input,REDUCED,FOLLOW_REDUCED_in_selectClause464);
 1509  10 
                             stream_REDUCED.add(REDUCED32);
 1510   
 
 1511   
 
 1512   
                             }
 1513   
                             break;
 1514   
 
 1515   
                     }
 1516   
 
 1517   
 
 1518   
                     // com\\googlecode\\sparkleg\\Sparql.g:104:36: (v+= selectVariables )+
 1519  982 
                     int cnt9=0;
 1520   
                     loop9:
 1521   
                     do {
 1522  2648 
                         int alt9=2;
 1523  2648 
                         switch ( input.LA(1) ) {
 1524   
                         case OPEN_BRACE:
 1525   
                         case VAR1:
 1526   
                         case VAR2:
 1527   
                             {
 1528  1666 
                             alt9=1;
 1529   
                             }
 1530   
                             break;
 1531   
 
 1532   
                         }
 1533   
 
 1534  2648 
                         switch (alt9) {
 1535   
                             case 1 :
 1536   
                                 // com\\googlecode\\sparkleg\\Sparql.g:104:37: v+= selectVariables
 1537   
                                 {
 1538  1666 
                                 pushFollow(FOLLOW_selectVariables_in_selectClause471);
 1539  1666 
                                 v=selectVariables();
 1540   
 
 1541  1666 
                                 state._fsp--;
 1542   
 
 1543  1666 
                                 stream_selectVariables.add(v.getTree());
 1544  1666 
                                 if (list_v==null) list_v=new ArrayList();
 1545  1666 
                                 list_v.add(v.getTree());
 1546   
 
 1547   
 
 1548   
                                 }
 1549  1666 
                                 break;
 1550   
 
 1551   
                             default :
 1552  982 
                                 if ( cnt9 >= 1 ) break loop9;
 1553  0 
                                 EarlyExitException eee =
 1554   
                                     new EarlyExitException(9, input);
 1555  0 
                                 throw eee;
 1556   
                         }
 1557  1666 
                         cnt9++;
 1558  1666 
                     } while (true);
 1559   
 
 1560   
 
 1561   
                     // AST REWRITE
 1562   
                     // elements: REDUCED, DISTINCT, v
 1563   
                     // token labels:
 1564   
                     // rule labels: retval
 1565   
                     // token list labels:
 1566   
                     // rule list labels: v
 1567   
                     // wildcard labels:
 1568  982 
                     retval.tree = root_0;
 1569  982 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1570  982 
                     RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 1571  982 
                     root_0 = (Object)adaptor.nil();
 1572   
                     // 104:58: -> ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1573   
                     {
 1574   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:61: ^( SELECT_CLAUSE ( DISTINCT )* ( REDUCED )* ( $v)* )
 1575   
                         {
 1576  982 
                         Object root_1 = (Object)adaptor.nil();
 1577  982 
                         root_1 = (Object)adaptor.becomeRoot(
 1578   
                         (Object)adaptor.create(SELECT_CLAUSE, "SELECT_CLAUSE")
 1579   
                         , root_1);
 1580   
 
 1581   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:77: ( DISTINCT )*
 1582  1024 
                         while ( stream_DISTINCT.hasNext() ) {
 1583  42 
                             adaptor.addChild(root_1,
 1584   
                             stream_DISTINCT.nextNode()
 1585   
                             );
 1586   
 
 1587   
                         }
 1588  982 
                         stream_DISTINCT.reset();
 1589   
 
 1590   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:87: ( REDUCED )*
 1591  992 
                         while ( stream_REDUCED.hasNext() ) {
 1592  10 
                             adaptor.addChild(root_1,
 1593   
                             stream_REDUCED.nextNode()
 1594   
                             );
 1595   
 
 1596   
                         }
 1597  982 
                         stream_REDUCED.reset();
 1598   
 
 1599   
                         // com\\googlecode\\sparkleg\\Sparql.g:104:97: ( $v)*
 1600  2648 
                         while ( stream_v.hasNext() ) {
 1601  1666 
                             adaptor.addChild(root_1, stream_v.nextTree());
 1602   
 
 1603   
                         }
 1604  982 
                         stream_v.reset();
 1605   
 
 1606  982 
                         adaptor.addChild(root_0, root_1);
 1607   
                         }
 1608   
 
 1609   
                     }
 1610   
 
 1611   
 
 1612  982 
                     retval.tree = root_0;
 1613   
 
 1614   
                     }
 1615   
                     break;
 1616   
 
 1617   
             }
 1618  1600 
             retval.stop = input.LT(-1);
 1619   
 
 1620   
 
 1621  1600 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1622  1600 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1623   
 
 1624   
         }
 1625  0 
         catch (RecognitionException re) {
 1626  0 
             reportError(re);
 1627  0 
             recover(input,re);
 1628  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1629   
 
 1630   
         }
 1631   
 
 1632  0 
         finally {
 1633   
                 // do for sure before leaving
 1634  1600 
         }
 1635  1600 
         return retval;
 1636   
     }
 1637   
     // $ANTLR end "selectClause"
 1638   
 
 1639   
 
 1640  1666 
     public static class selectVariables_return extends ParserRuleReturnScope {
 1641   
         Object tree;
 1642  3332 
         public Object getTree() { return tree; }
 1643   
     };
 1644   
 
 1645   
 
 1646   
     // $ANTLR start "selectVariables"
 1647   
     // com\\googlecode\\sparkleg\\Sparql.g:107:1: selectVariables : ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) );
 1648   
     public final SparqlParser.selectVariables_return selectVariables() throws RecognitionException {
 1649  1666 
         SparqlParser.selectVariables_return retval = new SparqlParser.selectVariables_return();
 1650  1666 
         retval.start = input.LT(1);
 1651   
 
 1652   
 
 1653  1666 
         Object root_0 = null;
 1654   
 
 1655  1666 
         Token OPEN_BRACE34=null;
 1656  1666 
         Token AS36=null;
 1657  1666 
         Token CLOSE_BRACE38=null;
 1658  1666 
         SparqlParser.var_return var33 =null;
 1659   
 
 1660  1666 
         SparqlParser.expression_return expression35 =null;
 1661   
 
 1662  1666 
         SparqlParser.var_return var37 =null;
 1663   
 
 1664   
 
 1665  1666 
         Object OPEN_BRACE34_tree=null;
 1666  1666 
         Object AS36_tree=null;
 1667  1666 
         Object CLOSE_BRACE38_tree=null;
 1668  1666 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 1669  1666 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 1670  1666 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 1671  1666 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 1672  1666 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 1673   
         try {
 1674   
             // com\\googlecode\\sparkleg\\Sparql.g:108:5: ( var -> ^( VAR var ) | OPEN_BRACE expression AS var CLOSE_BRACE -> ^( AS expression var ) )
 1675  1666 
             int alt11=2;
 1676  1666 
             switch ( input.LA(1) ) {
 1677   
             case VAR1:
 1678   
             case VAR2:
 1679   
                 {
 1680  1416 
                 alt11=1;
 1681   
                 }
 1682  1416 
                 break;
 1683   
             case OPEN_BRACE:
 1684   
                 {
 1685  250 
                 alt11=2;
 1686   
                 }
 1687  250 
                 break;
 1688   
             default:
 1689  0 
                 NoViableAltException nvae =
 1690   
                     new NoViableAltException("", 11, 0, input);
 1691   
 
 1692  0 
                 throw nvae;
 1693   
 
 1694   
             }
 1695   
 
 1696  1666 
             switch (alt11) {
 1697   
                 case 1 :
 1698   
                     // com\\googlecode\\sparkleg\\Sparql.g:108:7: var
 1699   
                     {
 1700  1416 
                     pushFollow(FOLLOW_var_in_selectVariables506);
 1701  1416 
                     var33=var();
 1702   
 
 1703  1416 
                     state._fsp--;
 1704   
 
 1705  1416 
                     stream_var.add(var33.getTree());
 1706   
 
 1707   
                     // AST REWRITE
 1708   
                     // elements: var
 1709   
                     // token labels:
 1710   
                     // rule labels: retval
 1711   
                     // token list labels:
 1712   
                     // rule list labels:
 1713   
                     // wildcard labels:
 1714  1416 
                     retval.tree = root_0;
 1715  1416 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1716   
 
 1717  1416 
                     root_0 = (Object)adaptor.nil();
 1718   
                     // 108:11: -> ^( VAR var )
 1719   
                     {
 1720   
                         // com\\googlecode\\sparkleg\\Sparql.g:108:14: ^( VAR var )
 1721   
                         {
 1722  1416 
                         Object root_1 = (Object)adaptor.nil();
 1723  1416 
                         root_1 = (Object)adaptor.becomeRoot(
 1724   
                         (Object)adaptor.create(VAR, "VAR")
 1725   
                         , root_1);
 1726   
 
 1727  1416 
                         adaptor.addChild(root_1, stream_var.nextTree());
 1728   
 
 1729  1416 
                         adaptor.addChild(root_0, root_1);
 1730   
                         }
 1731   
 
 1732   
                     }
 1733   
 
 1734   
 
 1735  1416 
                     retval.tree = root_0;
 1736   
 
 1737   
                     }
 1738  1416 
                     break;
 1739   
                 case 2 :
 1740   
                     // com\\googlecode\\sparkleg\\Sparql.g:109:7: OPEN_BRACE expression AS var CLOSE_BRACE
 1741   
                     {
 1742  250 
                     OPEN_BRACE34=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_selectVariables523);
 1743  250 
                     stream_OPEN_BRACE.add(OPEN_BRACE34);
 1744   
 
 1745   
 
 1746  250 
                     pushFollow(FOLLOW_expression_in_selectVariables525);
 1747  250 
                     expression35=expression();
 1748   
 
 1749  250 
                     state._fsp--;
 1750   
 
 1751  250 
                     stream_expression.add(expression35.getTree());
 1752   
 
 1753  250 
                     AS36=(Token)match(input,AS,FOLLOW_AS_in_selectVariables527);
 1754  250 
                     stream_AS.add(AS36);
 1755   
 
 1756   
 
 1757  250 
                     pushFollow(FOLLOW_var_in_selectVariables529);
 1758  250 
                     var37=var();
 1759   
 
 1760  250 
                     state._fsp--;
 1761   
 
 1762  250 
                     stream_var.add(var37.getTree());
 1763   
 
 1764  250 
                     CLOSE_BRACE38=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_selectVariables531);
 1765  250 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE38);
 1766   
 
 1767   
 
 1768   
                     // AST REWRITE
 1769   
                     // elements: var, expression, AS
 1770   
                     // token labels:
 1771   
                     // rule labels: retval
 1772   
                     // token list labels:
 1773   
                     // rule list labels:
 1774   
                     // wildcard labels:
 1775  250 
                     retval.tree = root_0;
 1776  250 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1777   
 
 1778  250 
                     root_0 = (Object)adaptor.nil();
 1779   
                     // 109:48: -> ^( AS expression var )
 1780   
                     {
 1781   
                         // com\\googlecode\\sparkleg\\Sparql.g:109:51: ^( AS expression var )
 1782   
                         {
 1783  250 
                         Object root_1 = (Object)adaptor.nil();
 1784  250 
                         root_1 = (Object)adaptor.becomeRoot(
 1785   
                         stream_AS.nextNode()
 1786   
                         , root_1);
 1787   
 
 1788  250 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 1789   
 
 1790  250 
                         adaptor.addChild(root_1, stream_var.nextTree());
 1791   
 
 1792  250 
                         adaptor.addChild(root_0, root_1);
 1793   
                         }
 1794   
 
 1795   
                     }
 1796   
 
 1797   
 
 1798  250 
                     retval.tree = root_0;
 1799   
 
 1800   
                     }
 1801   
                     break;
 1802   
 
 1803   
             }
 1804  1666 
             retval.stop = input.LT(-1);
 1805   
 
 1806   
 
 1807  1666 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 1808  1666 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 1809   
 
 1810   
         }
 1811  0 
         catch (RecognitionException re) {
 1812  0 
             reportError(re);
 1813  0 
             recover(input,re);
 1814  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 1815   
 
 1816   
         }
 1817   
 
 1818  0 
         finally {
 1819   
                 // do for sure before leaving
 1820  1666 
         }
 1821  1666 
         return retval;
 1822   
     }
 1823   
     // $ANTLR end "selectVariables"
 1824   
 
 1825   
 
 1826  70 
     public static class constructQuery_return extends ParserRuleReturnScope {
 1827   
         Object tree;
 1828  70 
         public Object getTree() { return tree; }
 1829   
     };
 1830   
 
 1831   
 
 1832   
     // $ANTLR start "constructQuery"
 1833   
     // com\\googlecode\\sparkleg\\Sparql.g:112:1: constructQuery : ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) );
 1834   
     public final SparqlParser.constructQuery_return constructQuery() throws RecognitionException {
 1835  70 
         SparqlParser.constructQuery_return retval = new SparqlParser.constructQuery_return();
 1836  70 
         retval.start = input.LT(1);
 1837   
 
 1838   
 
 1839  70 
         Object root_0 = null;
 1840   
 
 1841  70 
         Token CONSTRUCT39=null;
 1842  70 
         Token CONSTRUCT44=null;
 1843  70 
         Token WHERE46=null;
 1844  70 
         SparqlParser.constructTemplate_return constructTemplate40 =null;
 1845   
 
 1846  70 
         SparqlParser.datasetClause_return datasetClause41 =null;
 1847   
 
 1848  70 
         SparqlParser.whereClause_return whereClause42 =null;
 1849   
 
 1850  70 
         SparqlParser.solutionModifier_return solutionModifier43 =null;
 1851   
 
 1852  70 
         SparqlParser.datasetClause_return datasetClause45 =null;
 1853   
 
 1854  70 
         SparqlParser.groupGraphPattern_return groupGraphPattern47 =null;
 1855   
 
 1856  70 
         SparqlParser.solutionModifier_return solutionModifier48 =null;
 1857   
 
 1858   
 
 1859  70 
         Object CONSTRUCT39_tree=null;
 1860  70 
         Object CONSTRUCT44_tree=null;
 1861  70 
         Object WHERE46_tree=null;
 1862  70 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 1863  70 
         RewriteRuleTokenStream stream_CONSTRUCT=new RewriteRuleTokenStream(adaptor,"token CONSTRUCT");
 1864  70 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 1865  70 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 1866  70 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 1867  70 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 1868  70 
         RewriteRuleSubtreeStream stream_constructTemplate=new RewriteRuleSubtreeStream(adaptor,"rule constructTemplate");
 1869   
         try {
 1870   
             // com\\googlecode\\sparkleg\\Sparql.g:113:5: ( CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* ) | CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* ) )
 1871  70 
             int alt14=2;
 1872  70 
             switch ( input.LA(1) ) {
 1873   
             case CONSTRUCT:
 1874   
                 {
 1875  70 
                 switch ( input.LA(2) ) {
 1876   
                 case OPEN_CURLY_BRACE:
 1877   
                     {
 1878  54 
                     alt14=1;
 1879   
                     }
 1880  54 
                     break;
 1881   
                 case FROM:
 1882   
                 case WHERE:
 1883   
                     {
 1884  16 
                     alt14=2;
 1885   
                     }
 1886  16 
                     break;
 1887   
                 default:
 1888  0 
                     NoViableAltException nvae =
 1889   
                         new NoViableAltException("", 14, 1, input);
 1890   
 
 1891  0 
                     throw nvae;
 1892   
 
 1893   
                 }
 1894   
 
 1895   
                 }
 1896  70 
                 break;
 1897   
             default:
 1898  0 
                 NoViableAltException nvae =
 1899   
                     new NoViableAltException("", 14, 0, input);
 1900   
 
 1901  0 
                 throw nvae;
 1902   
 
 1903   
             }
 1904   
 
 1905  70 
             switch (alt14) {
 1906   
                 case 1 :
 1907   
                     // com\\googlecode\\sparkleg\\Sparql.g:113:7: CONSTRUCT constructTemplate ( datasetClause )* whereClause solutionModifier
 1908   
                     {
 1909  54 
                     CONSTRUCT39=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery558);
 1910  54 
                     stream_CONSTRUCT.add(CONSTRUCT39);
 1911   
 
 1912   
 
 1913  54 
                     pushFollow(FOLLOW_constructTemplate_in_constructQuery560);
 1914  54 
                     constructTemplate40=constructTemplate();
 1915   
 
 1916  54 
                     state._fsp--;
 1917   
 
 1918  54 
                     stream_constructTemplate.add(constructTemplate40.getTree());
 1919   
 
 1920   
                     // com\\googlecode\\sparkleg\\Sparql.g:113:35: ( datasetClause )*
 1921   
                     loop12:
 1922   
                     do {
 1923  54 
                         int alt12=2;
 1924  54 
                         switch ( input.LA(1) ) {
 1925   
                         case FROM:
 1926   
                             {
 1927  0 
                             alt12=1;
 1928   
                             }
 1929   
                             break;
 1930   
 
 1931   
                         }
 1932   
 
 1933  54 
                         switch (alt12) {
 1934   
                             case 1 :
 1935   
                                 // com\\googlecode\\sparkleg\\Sparql.g:113:35: datasetClause
 1936   
                                 {
 1937  0 
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery562);
 1938  0 
                                 datasetClause41=datasetClause();
 1939   
 
 1940  0 
                                 state._fsp--;
 1941   
 
 1942  0 
                                 stream_datasetClause.add(datasetClause41.getTree());
 1943   
 
 1944   
                                 }
 1945  0 
                                 break;
 1946   
 
 1947   
                             default :
 1948  54 
                                 break loop12;
 1949   
                         }
 1950  0 
                     } while (true);
 1951   
 
 1952   
 
 1953  54 
                     pushFollow(FOLLOW_whereClause_in_constructQuery565);
 1954  54 
                     whereClause42=whereClause();
 1955   
 
 1956  54 
                     state._fsp--;
 1957   
 
 1958  54 
                     stream_whereClause.add(whereClause42.getTree());
 1959   
 
 1960  54 
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery567);
 1961  54 
                     solutionModifier43=solutionModifier();
 1962   
 
 1963  54 
                     state._fsp--;
 1964   
 
 1965  54 
                     stream_solutionModifier.add(solutionModifier43.getTree());
 1966   
 
 1967   
                     // AST REWRITE
 1968   
                     // elements: constructTemplate, whereClause, solutionModifier, datasetClause, CONSTRUCT
 1969   
                     // token labels:
 1970   
                     // rule labels: retval
 1971   
                     // token list labels:
 1972   
                     // rule list labels:
 1973   
                     // wildcard labels:
 1974  54 
                     retval.tree = root_0;
 1975  54 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 1976   
 
 1977  54 
                     root_0 = (Object)adaptor.nil();
 1978   
                     // 113:79: -> ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1979   
                     {
 1980   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:82: ^( CONSTRUCT constructTemplate ( datasetClause )* ( whereClause )* ( solutionModifier )* )
 1981   
                         {
 1982  54 
                         Object root_1 = (Object)adaptor.nil();
 1983  54 
                         root_1 = (Object)adaptor.becomeRoot(
 1984   
                         stream_CONSTRUCT.nextNode()
 1985   
                         , root_1);
 1986   
 
 1987  54 
                         adaptor.addChild(root_1, stream_constructTemplate.nextTree());
 1988   
 
 1989   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:112: ( datasetClause )*
 1990  54 
                         while ( stream_datasetClause.hasNext() ) {
 1991  0 
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 1992   
 
 1993   
                         }
 1994  54 
                         stream_datasetClause.reset();
 1995   
 
 1996   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:127: ( whereClause )*
 1997  108 
                         while ( stream_whereClause.hasNext() ) {
 1998  54 
                             adaptor.addChild(root_1, stream_whereClause.nextTree());
 1999   
 
 2000   
                         }
 2001  54 
                         stream_whereClause.reset();
 2002   
 
 2003   
                         // com\\googlecode\\sparkleg\\Sparql.g:113:140: ( solutionModifier )*
 2004  60 
                         while ( stream_solutionModifier.hasNext() ) {
 2005  6 
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2006   
 
 2007   
                         }
 2008  54 
                         stream_solutionModifier.reset();
 2009   
 
 2010  54 
                         adaptor.addChild(root_0, root_1);
 2011   
                         }
 2012   
 
 2013   
                     }
 2014   
 
 2015   
 
 2016  54 
                     retval.tree = root_0;
 2017   
 
 2018   
                     }
 2019  54 
                     break;
 2020   
                 case 2 :
 2021   
                     // com\\googlecode\\sparkleg\\Sparql.g:114:7: CONSTRUCT ( datasetClause )* WHERE groupGraphPattern solutionModifier
 2022   
                     {
 2023  16 
                     CONSTRUCT44=(Token)match(input,CONSTRUCT,FOLLOW_CONSTRUCT_in_constructQuery592);
 2024  16 
                     stream_CONSTRUCT.add(CONSTRUCT44);
 2025   
 
 2026   
 
 2027   
                     // com\\googlecode\\sparkleg\\Sparql.g:114:17: ( datasetClause )*
 2028   
                     loop13:
 2029   
                     do {
 2030  18 
                         int alt13=2;
 2031  18 
                         switch ( input.LA(1) ) {
 2032   
                         case FROM:
 2033   
                             {
 2034  2 
                             alt13=1;
 2035   
                             }
 2036   
                             break;
 2037   
 
 2038   
                         }
 2039   
 
 2040  18 
                         switch (alt13) {
 2041   
                             case 1 :
 2042   
                                 // com\\googlecode\\sparkleg\\Sparql.g:114:17: datasetClause
 2043   
                                 {
 2044  2 
                                 pushFollow(FOLLOW_datasetClause_in_constructQuery594);
 2045  2 
                                 datasetClause45=datasetClause();
 2046   
 
 2047  2 
                                 state._fsp--;
 2048   
 
 2049  2 
                                 stream_datasetClause.add(datasetClause45.getTree());
 2050   
 
 2051   
                                 }
 2052  2 
                                 break;
 2053   
 
 2054   
                             default :
 2055  16 
                                 break loop13;
 2056   
                         }
 2057  2 
                     } while (true);
 2058   
 
 2059   
 
 2060  16 
                     WHERE46=(Token)match(input,WHERE,FOLLOW_WHERE_in_constructQuery597);
 2061  16 
                     stream_WHERE.add(WHERE46);
 2062   
 
 2063   
 
 2064  16 
                     pushFollow(FOLLOW_groupGraphPattern_in_constructQuery599);
 2065  16 
                     groupGraphPattern47=groupGraphPattern();
 2066   
 
 2067  16 
                     state._fsp--;
 2068   
 
 2069  16 
                     stream_groupGraphPattern.add(groupGraphPattern47.getTree());
 2070   
 
 2071  16 
                     pushFollow(FOLLOW_solutionModifier_in_constructQuery601);
 2072  16 
                     solutionModifier48=solutionModifier();
 2073   
 
 2074  16 
                     state._fsp--;
 2075   
 
 2076  16 
                     stream_solutionModifier.add(solutionModifier48.getTree());
 2077   
 
 2078   
                     // AST REWRITE
 2079   
                     // elements: groupGraphPattern, CONSTRUCT, datasetClause, solutionModifier
 2080   
                     // token labels:
 2081   
                     // rule labels: retval
 2082   
                     // token list labels:
 2083   
                     // rule list labels:
 2084   
                     // wildcard labels:
 2085  16 
                     retval.tree = root_0;
 2086  16 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2087   
 
 2088  16 
                     root_0 = (Object)adaptor.nil();
 2089   
                     // 114:73: -> ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2090   
                     {
 2091   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:76: ^( CONSTRUCT ( datasetClause )* ^( WHERE_CLAUSE ( groupGraphPattern )* ) ( solutionModifier )* )
 2092   
                         {
 2093  16 
                         Object root_1 = (Object)adaptor.nil();
 2094  16 
                         root_1 = (Object)adaptor.becomeRoot(
 2095   
                         stream_CONSTRUCT.nextNode()
 2096   
                         , root_1);
 2097   
 
 2098   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:88: ( datasetClause )*
 2099  18 
                         while ( stream_datasetClause.hasNext() ) {
 2100  2 
                             adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2101   
 
 2102   
                         }
 2103  16 
                         stream_datasetClause.reset();
 2104   
 
 2105   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:103: ^( WHERE_CLAUSE ( groupGraphPattern )* )
 2106   
                         {
 2107  16 
                         Object root_2 = (Object)adaptor.nil();
 2108  16 
                         root_2 = (Object)adaptor.becomeRoot(
 2109   
                         (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2110   
                         , root_2);
 2111   
 
 2112   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:118: ( groupGraphPattern )*
 2113  32 
                         while ( stream_groupGraphPattern.hasNext() ) {
 2114  16 
                             adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 2115   
 
 2116   
                         }
 2117  16 
                         stream_groupGraphPattern.reset();
 2118   
 
 2119  16 
                         adaptor.addChild(root_1, root_2);
 2120   
                         }
 2121   
 
 2122   
                         // com\\googlecode\\sparkleg\\Sparql.g:114:138: ( solutionModifier )*
 2123  16 
                         while ( stream_solutionModifier.hasNext() ) {
 2124  0 
                             adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2125   
 
 2126   
                         }
 2127  16 
                         stream_solutionModifier.reset();
 2128   
 
 2129  16 
                         adaptor.addChild(root_0, root_1);
 2130   
                         }
 2131   
 
 2132   
                     }
 2133   
 
 2134   
 
 2135  16 
                     retval.tree = root_0;
 2136   
 
 2137   
                     }
 2138   
                     break;
 2139   
 
 2140   
             }
 2141  70 
             retval.stop = input.LT(-1);
 2142   
 
 2143   
 
 2144  70 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2145  70 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2146   
 
 2147   
         }
 2148  0 
         catch (RecognitionException re) {
 2149  0 
             reportError(re);
 2150  0 
             recover(input,re);
 2151  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2152   
 
 2153   
         }
 2154   
 
 2155  0 
         finally {
 2156   
                 // do for sure before leaving
 2157  70 
         }
 2158  70 
         return retval;
 2159   
     }
 2160   
     // $ANTLR end "constructQuery"
 2161   
 
 2162   
 
 2163  28 
     public static class describeQuery_return extends ParserRuleReturnScope {
 2164   
         Object tree;
 2165  28 
         public Object getTree() { return tree; }
 2166   
     };
 2167   
 
 2168   
 
 2169   
     // $ANTLR start "describeQuery"
 2170   
     // com\\googlecode\\sparkleg\\Sparql.g:117:1: describeQuery : DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) ;
 2171   
     public final SparqlParser.describeQuery_return describeQuery() throws RecognitionException {
 2172  28 
         SparqlParser.describeQuery_return retval = new SparqlParser.describeQuery_return();
 2173  28 
         retval.start = input.LT(1);
 2174   
 
 2175   
 
 2176  28 
         Object root_0 = null;
 2177   
 
 2178  28 
         Token DESCRIBE49=null;
 2179  28 
         Token ASTERISK50=null;
 2180  28 
         List list_v=null;
 2181  28 
         SparqlParser.datasetClause_return datasetClause51 =null;
 2182   
 
 2183  28 
         SparqlParser.whereClause_return whereClause52 =null;
 2184   
 
 2185  28 
         SparqlParser.solutionModifier_return solutionModifier53 =null;
 2186   
 
 2187  28 
         RuleReturnScope v = null;
 2188  28 
         Object DESCRIBE49_tree=null;
 2189  28 
         Object ASTERISK50_tree=null;
 2190  28 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 2191  28 
         RewriteRuleTokenStream stream_DESCRIBE=new RewriteRuleTokenStream(adaptor,"token DESCRIBE");
 2192  28 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 2193  28 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2194  28 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2195  28 
         RewriteRuleSubtreeStream stream_solutionModifier=new RewriteRuleSubtreeStream(adaptor,"rule solutionModifier");
 2196   
         try {
 2197   
             // com\\googlecode\\sparkleg\\Sparql.g:118:5: ( DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* ) )
 2198   
             // com\\googlecode\\sparkleg\\Sparql.g:118:7: DESCRIBE ( (v+= varOrIRIref )+ | ASTERISK ) ( datasetClause )* ( whereClause )? solutionModifier
 2199   
             {
 2200  28 
             DESCRIBE49=(Token)match(input,DESCRIBE,FOLLOW_DESCRIBE_in_describeQuery637);
 2201  28 
             stream_DESCRIBE.add(DESCRIBE49);
 2202   
 
 2203   
 
 2204   
             // com\\googlecode\\sparkleg\\Sparql.g:118:16: ( (v+= varOrIRIref )+ | ASTERISK )
 2205  28 
             int alt16=2;
 2206  28 
             switch ( input.LA(1) ) {
 2207   
             case IRI_REF:
 2208   
             case PNAME_LN:
 2209   
             case PNAME_NS:
 2210   
             case VAR1:
 2211   
             case VAR2:
 2212   
                 {
 2213  28 
                 alt16=1;
 2214   
                 }
 2215  28 
                 break;
 2216   
             case ASTERISK:
 2217   
                 {
 2218  0 
                 alt16=2;
 2219   
                 }
 2220  0 
                 break;
 2221   
             default:
 2222  0 
                 NoViableAltException nvae =
 2223   
                     new NoViableAltException("", 16, 0, input);
 2224   
 
 2225  0 
                 throw nvae;
 2226   
 
 2227   
             }
 2228   
 
 2229  28 
             switch (alt16) {
 2230   
                 case 1 :
 2231   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2232   
                     {
 2233   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:17: (v+= varOrIRIref )+
 2234  28 
                     int cnt15=0;
 2235   
                     loop15:
 2236   
                     do {
 2237  70 
                         int alt15=2;
 2238  70 
                         switch ( input.LA(1) ) {
 2239   
                         case IRI_REF:
 2240   
                         case PNAME_LN:
 2241   
                         case PNAME_NS:
 2242   
                         case VAR1:
 2243   
                         case VAR2:
 2244   
                             {
 2245  42 
                             alt15=1;
 2246   
                             }
 2247   
                             break;
 2248   
 
 2249   
                         }
 2250   
 
 2251  70 
                         switch (alt15) {
 2252   
                             case 1 :
 2253   
                                 // com\\googlecode\\sparkleg\\Sparql.g:118:18: v+= varOrIRIref
 2254   
                                 {
 2255  42 
                                 pushFollow(FOLLOW_varOrIRIref_in_describeQuery643);
 2256  42 
                                 v=varOrIRIref();
 2257   
 
 2258  42 
                                 state._fsp--;
 2259   
 
 2260  42 
                                 stream_varOrIRIref.add(v.getTree());
 2261  42 
                                 if (list_v==null) list_v=new ArrayList();
 2262  42 
                                 list_v.add(v.getTree());
 2263   
 
 2264   
 
 2265   
                                 }
 2266  42 
                                 break;
 2267   
 
 2268   
                             default :
 2269  28 
                                 if ( cnt15 >= 1 ) break loop15;
 2270  0 
                                 EarlyExitException eee =
 2271   
                                     new EarlyExitException(15, input);
 2272  0 
                                 throw eee;
 2273   
                         }
 2274  42 
                         cnt15++;
 2275  42 
                     } while (true);
 2276   
 
 2277   
 
 2278   
                     }
 2279  28 
                     break;
 2280   
                 case 2 :
 2281   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:37: ASTERISK
 2282   
                     {
 2283  0 
                     ASTERISK50=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_describeQuery649);
 2284  0 
                     stream_ASTERISK.add(ASTERISK50);
 2285   
 
 2286   
 
 2287   
                     }
 2288   
                     break;
 2289   
 
 2290   
             }
 2291   
 
 2292   
 
 2293   
             // com\\googlecode\\sparkleg\\Sparql.g:118:47: ( datasetClause )*
 2294   
             loop17:
 2295   
             do {
 2296  28 
                 int alt17=2;
 2297  28 
                 switch ( input.LA(1) ) {
 2298   
                 case FROM:
 2299   
                     {
 2300  0 
                     alt17=1;
 2301   
                     }
 2302   
                     break;
 2303   
 
 2304   
                 }
 2305   
 
 2306  28 
                 switch (alt17) {
 2307   
                     case 1 :
 2308   
                         // com\\googlecode\\sparkleg\\Sparql.g:118:47: datasetClause
 2309   
                         {
 2310  0 
                         pushFollow(FOLLOW_datasetClause_in_describeQuery652);
 2311  0 
                         datasetClause51=datasetClause();
 2312   
 
 2313  0 
                         state._fsp--;
 2314   
 
 2315  0 
                         stream_datasetClause.add(datasetClause51.getTree());
 2316   
 
 2317   
                         }
 2318  0 
                         break;
 2319   
 
 2320   
                     default :
 2321  28 
                         break loop17;
 2322   
                 }
 2323  0 
             } while (true);
 2324   
 
 2325   
 
 2326   
             // com\\googlecode\\sparkleg\\Sparql.g:118:62: ( whereClause )?
 2327  28 
             int alt18=2;
 2328  28 
             switch ( input.LA(1) ) {
 2329   
                 case OPEN_CURLY_BRACE:
 2330   
                 case WHERE:
 2331   
                     {
 2332  22 
                     alt18=1;
 2333   
                     }
 2334   
                     break;
 2335   
             }
 2336   
 
 2337  28 
             switch (alt18) {
 2338   
                 case 1 :
 2339   
                     // com\\googlecode\\sparkleg\\Sparql.g:118:62: whereClause
 2340   
                     {
 2341  22 
                     pushFollow(FOLLOW_whereClause_in_describeQuery655);
 2342  22 
                     whereClause52=whereClause();
 2343   
 
 2344  22 
                     state._fsp--;
 2345   
 
 2346  22 
                     stream_whereClause.add(whereClause52.getTree());
 2347   
 
 2348   
                     }
 2349   
                     break;
 2350   
 
 2351   
             }
 2352   
 
 2353   
 
 2354  28 
             pushFollow(FOLLOW_solutionModifier_in_describeQuery658);
 2355  28 
             solutionModifier53=solutionModifier();
 2356   
 
 2357  28 
             state._fsp--;
 2358   
 
 2359  28 
             stream_solutionModifier.add(solutionModifier53.getTree());
 2360   
 
 2361   
             // AST REWRITE
 2362   
             // elements: v, solutionModifier, datasetClause, DESCRIBE, ASTERISK, whereClause
 2363   
             // token labels:
 2364   
             // rule labels: retval
 2365   
             // token list labels:
 2366   
             // rule list labels: v
 2367   
             // wildcard labels:
 2368  28 
             retval.tree = root_0;
 2369  28 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2370  28 
             RewriteRuleSubtreeStream stream_v=new RewriteRuleSubtreeStream(adaptor,"token v",list_v);
 2371  28 
             root_0 = (Object)adaptor.nil();
 2372   
             // 118:92: -> ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2373   
             {
 2374   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:95: ^( DESCRIBE ( $v)* ( ASTERISK )* ( datasetClause )* ( whereClause )? ( solutionModifier )* )
 2375   
                 {
 2376  28 
                 Object root_1 = (Object)adaptor.nil();
 2377  28 
                 root_1 = (Object)adaptor.becomeRoot(
 2378   
                 stream_DESCRIBE.nextNode()
 2379   
                 , root_1);
 2380   
 
 2381   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:107: ( $v)*
 2382  70 
                 while ( stream_v.hasNext() ) {
 2383  42 
                     adaptor.addChild(root_1, stream_v.nextTree());
 2384   
 
 2385   
                 }
 2386  28 
                 stream_v.reset();
 2387   
 
 2388   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:110: ( ASTERISK )*
 2389  28 
                 while ( stream_ASTERISK.hasNext() ) {
 2390  0 
                     adaptor.addChild(root_1,
 2391   
                     stream_ASTERISK.nextNode()
 2392   
                     );
 2393   
 
 2394   
                 }
 2395  28 
                 stream_ASTERISK.reset();
 2396   
 
 2397   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:120: ( datasetClause )*
 2398  28 
                 while ( stream_datasetClause.hasNext() ) {
 2399  0 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2400   
 
 2401   
                 }
 2402  28 
                 stream_datasetClause.reset();
 2403   
 
 2404   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:135: ( whereClause )?
 2405  28 
                 if ( stream_whereClause.hasNext() ) {
 2406  22 
                     adaptor.addChild(root_1, stream_whereClause.nextTree());
 2407   
 
 2408   
                 }
 2409  28 
                 stream_whereClause.reset();
 2410   
 
 2411   
                 // com\\googlecode\\sparkleg\\Sparql.g:118:148: ( solutionModifier )*
 2412  28 
                 while ( stream_solutionModifier.hasNext() ) {
 2413  0 
                     adaptor.addChild(root_1, stream_solutionModifier.nextTree());
 2414   
 
 2415   
                 }
 2416  28 
                 stream_solutionModifier.reset();
 2417   
 
 2418  28 
                 adaptor.addChild(root_0, root_1);
 2419   
                 }
 2420   
 
 2421   
             }
 2422   
 
 2423   
 
 2424  28 
             retval.tree = root_0;
 2425   
 
 2426   
             }
 2427   
 
 2428  28 
             retval.stop = input.LT(-1);
 2429   
 
 2430   
 
 2431  28 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2432  28 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2433   
 
 2434   
         }
 2435  0 
         catch (RecognitionException re) {
 2436  0 
             reportError(re);
 2437  0 
             recover(input,re);
 2438  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2439   
 
 2440   
         }
 2441   
 
 2442  0 
         finally {
 2443   
                 // do for sure before leaving
 2444  28 
         }
 2445  28 
         return retval;
 2446   
     }
 2447   
     // $ANTLR end "describeQuery"
 2448   
 
 2449   
 
 2450  122 
     public static class askQuery_return extends ParserRuleReturnScope {
 2451   
         Object tree;
 2452  122 
         public Object getTree() { return tree; }
 2453   
     };
 2454   
 
 2455   
 
 2456   
     // $ANTLR start "askQuery"
 2457   
     // com\\googlecode\\sparkleg\\Sparql.g:121:1: askQuery : ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) ;
 2458   
     public final SparqlParser.askQuery_return askQuery() throws RecognitionException {
 2459  122 
         SparqlParser.askQuery_return retval = new SparqlParser.askQuery_return();
 2460  122 
         retval.start = input.LT(1);
 2461   
 
 2462   
 
 2463  122 
         Object root_0 = null;
 2464   
 
 2465  122 
         Token ASK54=null;
 2466  122 
         SparqlParser.datasetClause_return datasetClause55 =null;
 2467   
 
 2468  122 
         SparqlParser.whereClause_return whereClause56 =null;
 2469   
 
 2470   
 
 2471  122 
         Object ASK54_tree=null;
 2472  122 
         RewriteRuleTokenStream stream_ASK=new RewriteRuleTokenStream(adaptor,"token ASK");
 2473  122 
         RewriteRuleSubtreeStream stream_whereClause=new RewriteRuleSubtreeStream(adaptor,"rule whereClause");
 2474  122 
         RewriteRuleSubtreeStream stream_datasetClause=new RewriteRuleSubtreeStream(adaptor,"rule datasetClause");
 2475   
         try {
 2476   
             // com\\googlecode\\sparkleg\\Sparql.g:122:5: ( ASK ( datasetClause )* whereClause -> ^( ASK ( datasetClause )* whereClause ) )
 2477   
             // com\\googlecode\\sparkleg\\Sparql.g:122:7: ASK ( datasetClause )* whereClause
 2478   
             {
 2479  122 
             ASK54=(Token)match(input,ASK,FOLLOW_ASK_in_askQuery697);
 2480  122 
             stream_ASK.add(ASK54);
 2481   
 
 2482   
 
 2483   
             // com\\googlecode\\sparkleg\\Sparql.g:122:11: ( datasetClause )*
 2484   
             loop19:
 2485   
             do {
 2486  122 
                 int alt19=2;
 2487  122 
                 switch ( input.LA(1) ) {
 2488   
                 case FROM:
 2489   
                     {
 2490  0 
                     alt19=1;
 2491   
                     }
 2492   
                     break;
 2493   
 
 2494   
                 }
 2495   
 
 2496  122 
                 switch (alt19) {
 2497   
                     case 1 :
 2498   
                         // com\\googlecode\\sparkleg\\Sparql.g:122:11: datasetClause
 2499   
                         {
 2500  0 
                         pushFollow(FOLLOW_datasetClause_in_askQuery699);
 2501  0 
                         datasetClause55=datasetClause();
 2502   
 
 2503  0 
                         state._fsp--;
 2504   
 
 2505  0 
                         stream_datasetClause.add(datasetClause55.getTree());
 2506   
 
 2507   
                         }
 2508  0 
                         break;
 2509   
 
 2510   
                     default :
 2511  122 
                         break loop19;
 2512   
                 }
 2513  0 
             } while (true);
 2514   
 
 2515   
 
 2516  122 
             pushFollow(FOLLOW_whereClause_in_askQuery702);
 2517  122 
             whereClause56=whereClause();
 2518   
 
 2519  122 
             state._fsp--;
 2520   
 
 2521  122 
             stream_whereClause.add(whereClause56.getTree());
 2522   
 
 2523   
             // AST REWRITE
 2524   
             // elements: datasetClause, ASK, whereClause
 2525   
             // token labels:
 2526   
             // rule labels: retval
 2527   
             // token list labels:
 2528   
             // rule list labels:
 2529   
             // wildcard labels:
 2530  122 
             retval.tree = root_0;
 2531  122 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2532   
 
 2533  122 
             root_0 = (Object)adaptor.nil();
 2534   
             // 122:38: -> ^( ASK ( datasetClause )* whereClause )
 2535   
             {
 2536   
                 // com\\googlecode\\sparkleg\\Sparql.g:122:41: ^( ASK ( datasetClause )* whereClause )
 2537   
                 {
 2538  122 
                 Object root_1 = (Object)adaptor.nil();
 2539  122 
                 root_1 = (Object)adaptor.becomeRoot(
 2540   
                 stream_ASK.nextNode()
 2541   
                 , root_1);
 2542   
 
 2543   
                 // com\\googlecode\\sparkleg\\Sparql.g:122:47: ( datasetClause )*
 2544  122 
                 while ( stream_datasetClause.hasNext() ) {
 2545  0 
                     adaptor.addChild(root_1, stream_datasetClause.nextTree());
 2546   
 
 2547   
                 }
 2548  122 
                 stream_datasetClause.reset();
 2549   
 
 2550  122 
                 adaptor.addChild(root_1, stream_whereClause.nextTree());
 2551   
 
 2552  122 
                 adaptor.addChild(root_0, root_1);
 2553   
                 }
 2554   
 
 2555   
             }
 2556   
 
 2557   
 
 2558  122 
             retval.tree = root_0;
 2559   
 
 2560   
             }
 2561   
 
 2562  122 
             retval.stop = input.LT(-1);
 2563   
 
 2564   
 
 2565  122 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2566  122 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2567   
 
 2568   
         }
 2569  0 
         catch (RecognitionException re) {
 2570  0 
             reportError(re);
 2571  0 
             recover(input,re);
 2572  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2573   
 
 2574   
         }
 2575   
 
 2576  0 
         finally {
 2577   
                 // do for sure before leaving
 2578  122 
         }
 2579  122 
         return retval;
 2580   
     }
 2581   
     // $ANTLR end "askQuery"
 2582   
 
 2583   
 
 2584  160 
     public static class datasetClause_return extends ParserRuleReturnScope {
 2585   
         Object tree;
 2586  160 
         public Object getTree() { return tree; }
 2587   
     };
 2588   
 
 2589   
 
 2590   
     // $ANTLR start "datasetClause"
 2591   
     // com\\googlecode\\sparkleg\\Sparql.g:125:1: datasetClause : FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) ;
 2592   
     public final SparqlParser.datasetClause_return datasetClause() throws RecognitionException {
 2593  160 
         SparqlParser.datasetClause_return retval = new SparqlParser.datasetClause_return();
 2594  160 
         retval.start = input.LT(1);
 2595   
 
 2596   
 
 2597  160 
         Object root_0 = null;
 2598   
 
 2599  160 
         Token FROM57=null;
 2600  160 
         Token NAMED58=null;
 2601  160 
         SparqlParser.iriRef_return iriRef59 =null;
 2602   
 
 2603   
 
 2604  160 
         Object FROM57_tree=null;
 2605  160 
         Object NAMED58_tree=null;
 2606  160 
         RewriteRuleTokenStream stream_FROM=new RewriteRuleTokenStream(adaptor,"token FROM");
 2607  160 
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 2608  160 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 2609   
         try {
 2610   
             // com\\googlecode\\sparkleg\\Sparql.g:126:5: ( FROM ( NAMED )? iriRef -> ^( FROM ( NAMED )? iriRef ) )
 2611   
             // com\\googlecode\\sparkleg\\Sparql.g:126:7: FROM ( NAMED )? iriRef
 2612   
             {
 2613  160 
             FROM57=(Token)match(input,FROM,FOLLOW_FROM_in_datasetClause730);
 2614  160 
             stream_FROM.add(FROM57);
 2615   
 
 2616   
 
 2617   
             // com\\googlecode\\sparkleg\\Sparql.g:126:12: ( NAMED )?
 2618  160 
             int alt20=2;
 2619  160 
             switch ( input.LA(1) ) {
 2620   
                 case NAMED:
 2621   
                     {
 2622  102 
                     alt20=1;
 2623   
                     }
 2624   
                     break;
 2625   
             }
 2626   
 
 2627  160 
             switch (alt20) {
 2628   
                 case 1 :
 2629   
                     // com\\googlecode\\sparkleg\\Sparql.g:126:12: NAMED
 2630   
                     {
 2631  102 
                     NAMED58=(Token)match(input,NAMED,FOLLOW_NAMED_in_datasetClause732);
 2632  102 
                     stream_NAMED.add(NAMED58);
 2633   
 
 2634   
 
 2635   
                     }
 2636   
                     break;
 2637   
 
 2638   
             }
 2639   
 
 2640   
 
 2641  160 
             pushFollow(FOLLOW_iriRef_in_datasetClause735);
 2642  160 
             iriRef59=iriRef();
 2643   
 
 2644  160 
             state._fsp--;
 2645   
 
 2646  160 
             stream_iriRef.add(iriRef59.getTree());
 2647   
 
 2648   
             // AST REWRITE
 2649   
             // elements: NAMED, FROM, iriRef
 2650   
             // token labels:
 2651   
             // rule labels: retval
 2652   
             // token list labels:
 2653   
             // rule list labels:
 2654   
             // wildcard labels:
 2655  160 
             retval.tree = root_0;
 2656  160 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2657   
 
 2658  160 
             root_0 = (Object)adaptor.nil();
 2659   
             // 126:26: -> ^( FROM ( NAMED )? iriRef )
 2660   
             {
 2661   
                 // com\\googlecode\\sparkleg\\Sparql.g:126:29: ^( FROM ( NAMED )? iriRef )
 2662   
                 {
 2663  160 
                 Object root_1 = (Object)adaptor.nil();
 2664  160 
                 root_1 = (Object)adaptor.becomeRoot(
 2665   
                 stream_FROM.nextNode()
 2666   
                 , root_1);
 2667   
 
 2668   
                 // com\\googlecode\\sparkleg\\Sparql.g:126:36: ( NAMED )?
 2669  160 
                 if ( stream_NAMED.hasNext() ) {
 2670  102 
                     adaptor.addChild(root_1,
 2671   
                     stream_NAMED.nextNode()
 2672   
                     );
 2673   
 
 2674   
                 }
 2675  160 
                 stream_NAMED.reset();
 2676   
 
 2677  160 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 2678   
 
 2679  160 
                 adaptor.addChild(root_0, root_1);
 2680   
                 }
 2681   
 
 2682   
             }
 2683   
 
 2684   
 
 2685  160 
             retval.tree = root_0;
 2686   
 
 2687   
             }
 2688   
 
 2689  160 
             retval.stop = input.LT(-1);
 2690   
 
 2691   
 
 2692  160 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2693  160 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2694   
 
 2695   
         }
 2696  0 
         catch (RecognitionException re) {
 2697  0 
             reportError(re);
 2698  0 
             recover(input,re);
 2699  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2700   
 
 2701   
         }
 2702   
 
 2703  0 
         finally {
 2704   
                 // do for sure before leaving
 2705  160 
         }
 2706  160 
         return retval;
 2707   
     }
 2708   
     // $ANTLR end "datasetClause"
 2709   
 
 2710   
 
 2711  1798 
     public static class whereClause_return extends ParserRuleReturnScope {
 2712   
         Object tree;
 2713  1798 
         public Object getTree() { return tree; }
 2714   
     };
 2715   
 
 2716   
 
 2717   
     // $ANTLR start "whereClause"
 2718   
     // com\\googlecode\\sparkleg\\Sparql.g:129:1: whereClause : ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) ;
 2719   
     public final SparqlParser.whereClause_return whereClause() throws RecognitionException {
 2720  1798 
         SparqlParser.whereClause_return retval = new SparqlParser.whereClause_return();
 2721  1798 
         retval.start = input.LT(1);
 2722   
 
 2723   
 
 2724  1798 
         Object root_0 = null;
 2725   
 
 2726  1798 
         Token WHERE60=null;
 2727  1798 
         SparqlParser.groupGraphPattern_return groupGraphPattern61 =null;
 2728   
 
 2729   
 
 2730  1798 
         Object WHERE60_tree=null;
 2731  1798 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 2732  1798 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 2733   
         try {
 2734   
             // com\\googlecode\\sparkleg\\Sparql.g:130:5: ( ( WHERE )? groupGraphPattern -> ^( WHERE_CLAUSE groupGraphPattern ) )
 2735   
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )? groupGraphPattern
 2736   
             {
 2737   
             // com\\googlecode\\sparkleg\\Sparql.g:130:7: ( WHERE )?
 2738  1798 
             int alt21=2;
 2739  1798 
             switch ( input.LA(1) ) {
 2740   
                 case WHERE:
 2741   
                     {
 2742  1553 
                     alt21=1;
 2743   
                     }
 2744   
                     break;
 2745   
             }
 2746   
 
 2747  1798 
             switch (alt21) {
 2748   
                 case 1 :
 2749   
                     // com\\googlecode\\sparkleg\\Sparql.g:130:7: WHERE
 2750   
                     {
 2751  1553 
                     WHERE60=(Token)match(input,WHERE,FOLLOW_WHERE_in_whereClause763);
 2752  1553 
                     stream_WHERE.add(WHERE60);
 2753   
 
 2754   
 
 2755   
                     }
 2756   
                     break;
 2757   
 
 2758   
             }
 2759   
 
 2760   
 
 2761  1798 
             pushFollow(FOLLOW_groupGraphPattern_in_whereClause766);
 2762  1798 
             groupGraphPattern61=groupGraphPattern();
 2763   
 
 2764  1798 
             state._fsp--;
 2765   
 
 2766  1798 
             stream_groupGraphPattern.add(groupGraphPattern61.getTree());
 2767   
 
 2768   
             // AST REWRITE
 2769   
             // elements: groupGraphPattern
 2770   
             // token labels:
 2771   
             // rule labels: retval
 2772   
             // token list labels:
 2773   
             // rule list labels:
 2774   
             // wildcard labels:
 2775  1798 
             retval.tree = root_0;
 2776  1798 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2777   
 
 2778  1798 
             root_0 = (Object)adaptor.nil();
 2779   
             // 130:32: -> ^( WHERE_CLAUSE groupGraphPattern )
 2780   
             {
 2781   
                 // com\\googlecode\\sparkleg\\Sparql.g:130:35: ^( WHERE_CLAUSE groupGraphPattern )
 2782   
                 {
 2783  1798 
                 Object root_1 = (Object)adaptor.nil();
 2784  1798 
                 root_1 = (Object)adaptor.becomeRoot(
 2785   
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 2786   
                 , root_1);
 2787   
 
 2788  1798 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 2789   
 
 2790  1798 
                 adaptor.addChild(root_0, root_1);
 2791   
                 }
 2792   
 
 2793   
             }
 2794   
 
 2795   
 
 2796  1798 
             retval.tree = root_0;
 2797   
 
 2798   
             }
 2799   
 
 2800  1798 
             retval.stop = input.LT(-1);
 2801   
 
 2802   
 
 2803  1798 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 2804  1798 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 2805   
 
 2806   
         }
 2807  0 
         catch (RecognitionException re) {
 2808  0 
             reportError(re);
 2809  0 
             recover(input,re);
 2810  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 2811   
 
 2812   
         }
 2813   
 
 2814  0 
         finally {
 2815   
                 // do for sure before leaving
 2816  1798 
         }
 2817  1798 
         return retval;
 2818   
     }
 2819   
     // $ANTLR end "whereClause"
 2820   
 
 2821   
 
 2822  1698 
     public static class solutionModifier_return extends ParserRuleReturnScope {
 2823   
         Object tree;
 2824  1698 
         public Object getTree() { return tree; }
 2825   
     };
 2826   
 
 2827   
 
 2828   
     // $ANTLR start "solutionModifier"
 2829   
     // com\\googlecode\\sparkleg\\Sparql.g:133:1: solutionModifier : ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* ;
 2830   
     public final SparqlParser.solutionModifier_return solutionModifier() throws RecognitionException {
 2831  1698 
         SparqlParser.solutionModifier_return retval = new SparqlParser.solutionModifier_return();
 2832  1698 
         retval.start = input.LT(1);
 2833   
 
 2834   
 
 2835  1698 
         Object root_0 = null;
 2836   
 
 2837  1698 
         SparqlParser.groupClause_return groupClause62 =null;
 2838   
 
 2839  1698 
         SparqlParser.havingClause_return havingClause63 =null;
 2840   
 
 2841  1698 
         SparqlParser.orderClause_return orderClause64 =null;
 2842   
 
 2843  1698 
         SparqlParser.limitOffsetClauses_return limitOffsetClauses65 =null;
 2844   
 
 2845   
 
 2846  1698 
         RewriteRuleSubtreeStream stream_limitOffsetClauses=new RewriteRuleSubtreeStream(adaptor,"rule limitOffsetClauses");
 2847  1698 
         RewriteRuleSubtreeStream stream_orderClause=new RewriteRuleSubtreeStream(adaptor,"rule orderClause");
 2848  1698 
         RewriteRuleSubtreeStream stream_groupClause=new RewriteRuleSubtreeStream(adaptor,"rule groupClause");
 2849  1698 
         RewriteRuleSubtreeStream stream_havingClause=new RewriteRuleSubtreeStream(adaptor,"rule havingClause");
 2850   
         try {
 2851   
             // com\\googlecode\\sparkleg\\Sparql.g:134:5: ( ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )? -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )* )
 2852   
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )? ( havingClause )? ( orderClause )? ( limitOffsetClauses )?
 2853   
             {
 2854   
             // com\\googlecode\\sparkleg\\Sparql.g:134:7: ( groupClause )?
 2855  1698 
             int alt22=2;
 2856  1698 
             switch ( input.LA(1) ) {
 2857   
                 case GROUP:
 2858   
                     {
 2859  66 
                     alt22=1;
 2860   
                     }
 2861   
                     break;
 2862   
             }
 2863   
 
 2864  1698 
             switch (alt22) {
 2865   
                 case 1 :
 2866   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:7: groupClause
 2867   
                     {
 2868  66 
                     pushFollow(FOLLOW_groupClause_in_solutionModifier791);
 2869  66 
                     groupClause62=groupClause();
 2870   
 
 2871  66 
                     state._fsp--;
 2872   
 
 2873  66 
                     stream_groupClause.add(groupClause62.getTree());
 2874   
 
 2875   
                     }
 2876   
                     break;
 2877   
 
 2878   
             }
 2879   
 
 2880   
 
 2881   
             // com\\googlecode\\sparkleg\\Sparql.g:134:20: ( havingClause )?
 2882  1698 
             int alt23=2;
 2883  1698 
             switch ( input.LA(1) ) {
 2884   
                 case HAVING:
 2885   
                     {
 2886  16 
                     alt23=1;
 2887   
                     }
 2888   
                     break;
 2889   
             }
 2890   
 
 2891  1698 
             switch (alt23) {
 2892   
                 case 1 :
 2893   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:20: havingClause
 2894   
                     {
 2895  16 
                     pushFollow(FOLLOW_havingClause_in_solutionModifier794);
 2896  16 
                     havingClause63=havingClause();
 2897   
 
 2898  16 
                     state._fsp--;
 2899   
 
 2900  16 
                     stream_havingClause.add(havingClause63.getTree());
 2901   
 
 2902   
                     }
 2903   
                     break;
 2904   
 
 2905   
             }
 2906   
 
 2907   
 
 2908   
             // com\\googlecode\\sparkleg\\Sparql.g:134:34: ( orderClause )?
 2909  1698 
             int alt24=2;
 2910  1698 
             switch ( input.LA(1) ) {
 2911   
                 case ORDER:
 2912   
                     {
 2913  134 
                     alt24=1;
 2914   
                     }
 2915   
                     break;
 2916   
             }
 2917   
 
 2918  1698 
             switch (alt24) {
 2919   
                 case 1 :
 2920   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:34: orderClause
 2921   
                     {
 2922  134 
                     pushFollow(FOLLOW_orderClause_in_solutionModifier797);
 2923  134 
                     orderClause64=orderClause();
 2924   
 
 2925  134 
                     state._fsp--;
 2926   
 
 2927  134 
                     stream_orderClause.add(orderClause64.getTree());
 2928   
 
 2929   
                     }
 2930   
                     break;
 2931   
 
 2932   
             }
 2933   
 
 2934   
 
 2935   
             // com\\googlecode\\sparkleg\\Sparql.g:134:47: ( limitOffsetClauses )?
 2936  1698 
             int alt25=2;
 2937  1698 
             switch ( input.LA(1) ) {
 2938   
                 case LIMIT:
 2939   
                 case OFFSET:
 2940   
                     {
 2941  58 
                     alt25=1;
 2942   
                     }
 2943   
                     break;
 2944   
             }
 2945   
 
 2946  1698 
             switch (alt25) {
 2947   
                 case 1 :
 2948   
                     // com\\googlecode\\sparkleg\\Sparql.g:134:47: limitOffsetClauses
 2949   
                     {
 2950  58 
                     pushFollow(FOLLOW_limitOffsetClauses_in_solutionModifier800);
 2951  58 
                     limitOffsetClauses65=limitOffsetClauses();
 2952   
 
 2953  58 
                     state._fsp--;
 2954   
 
 2955  58 
                     stream_limitOffsetClauses.add(limitOffsetClauses65.getTree());
 2956   
 
 2957   
                     }
 2958   
                     break;
 2959   
 
 2960   
             }
 2961   
 
 2962   
 
 2963   
             // AST REWRITE
 2964   
             // elements: havingClause, orderClause, groupClause, limitOffsetClauses
 2965   
             // token labels:
 2966   
             // rule labels: retval
 2967   
             // token list labels:
 2968   
             // rule list labels:
 2969   
             // wildcard labels:
 2970  1698 
             retval.tree = root_0;
 2971  1698 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 2972   
 
 2973  1698 
             root_0 = (Object)adaptor.nil();
 2974   
             // 134:67: -> ( groupClause )* ( havingClause )* ( orderClause )* ( limitOffsetClauses )*
 2975   
             {
 2976   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:70: ( groupClause )*
 2977  1764 
                 while ( stream_groupClause.hasNext() ) {
 2978  66 
                     adaptor.addChild(root_0, stream_groupClause.nextTree());
 2979   
 
 2980   
                 }
 2981  1698 
                 stream_groupClause.reset();
 2982   
 
 2983   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:83: ( havingClause )*
 2984  1714 
                 while ( stream_havingClause.hasNext() ) {
 2985  16 
                     adaptor.addChild(root_0, stream_havingClause.nextTree());
 2986   
 
 2987   
                 }
 2988  1698 
                 stream_havingClause.reset();
 2989   
 
 2990   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:97: ( orderClause )*
 2991  1832 
                 while ( stream_orderClause.hasNext() ) {
 2992  134 
                     adaptor.addChild(root_0, stream_orderClause.nextTree());
 2993   
 
 2994   
                 }
 2995  1698 
                 stream_orderClause.reset();
 2996   
 
 2997   
                 // com\\googlecode\\sparkleg\\Sparql.g:134:110: ( limitOffsetClauses )*
 2998  1756 
                 while ( stream_limitOffsetClauses.hasNext() ) {
 2999  58 
                     adaptor.addChild(root_0, stream_limitOffsetClauses.nextTree());
 3000   
 
 3001   
                 }
 3002  1698 
                 stream_limitOffsetClauses.reset();
 3003   
 
 3004   
             }
 3005   
 
 3006   
 
 3007  1698 
             retval.tree = root_0;
 3008   
 
 3009   
             }
 3010   
 
 3011  1698 
             retval.stop = input.LT(-1);
 3012   
 
 3013   
 
 3014  1698 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3015  1698 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3016   
 
 3017   
         }
 3018  0 
         catch (RecognitionException re) {
 3019  0 
             reportError(re);
 3020  0 
             recover(input,re);
 3021  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3022   
 
 3023   
         }
 3024   
 
 3025  0 
         finally {
 3026   
                 // do for sure before leaving
 3027  1698 
         }
 3028  1698 
         return retval;
 3029   
     }
 3030   
     // $ANTLR end "solutionModifier"
 3031   
 
 3032   
 
 3033  66 
     public static class groupClause_return extends ParserRuleReturnScope {
 3034   
         Object tree;
 3035  66 
         public Object getTree() { return tree; }
 3036   
     };
 3037   
 
 3038   
 
 3039   
     // $ANTLR start "groupClause"
 3040   
     // com\\googlecode\\sparkleg\\Sparql.g:137:1: groupClause : GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) ;
 3041   
     public final SparqlParser.groupClause_return groupClause() throws RecognitionException {
 3042  66 
         SparqlParser.groupClause_return retval = new SparqlParser.groupClause_return();
 3043  66 
         retval.start = input.LT(1);
 3044   
 
 3045   
 
 3046  66 
         Object root_0 = null;
 3047   
 
 3048  66 
         Token GROUP66=null;
 3049  66 
         Token BY67=null;
 3050  66 
         SparqlParser.groupCondition_return groupCondition68 =null;
 3051   
 
 3052   
 
 3053  66 
         Object GROUP66_tree=null;
 3054  66 
         Object BY67_tree=null;
 3055  66 
         RewriteRuleTokenStream stream_GROUP=new RewriteRuleTokenStream(adaptor,"token GROUP");
 3056  66 
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3057  66 
         RewriteRuleSubtreeStream stream_groupCondition=new RewriteRuleSubtreeStream(adaptor,"rule groupCondition");
 3058   
         try {
 3059   
             // com\\googlecode\\sparkleg\\Sparql.g:138:5: ( GROUP BY ( groupCondition )+ -> ^( GROUP_BY ( groupCondition )+ ) )
 3060   
             // com\\googlecode\\sparkleg\\Sparql.g:138:7: GROUP BY ( groupCondition )+
 3061   
             {
 3062  66 
             GROUP66=(Token)match(input,GROUP,FOLLOW_GROUP_in_groupClause832);
 3063  66 
             stream_GROUP.add(GROUP66);
 3064   
 
 3065   
 
 3066  66 
             BY67=(Token)match(input,BY,FOLLOW_BY_in_groupClause834);
 3067  66 
             stream_BY.add(BY67);
 3068   
 
 3069   
 
 3070   
             // com\\googlecode\\sparkleg\\Sparql.g:138:16: ( groupCondition )+
 3071  66 
             int cnt26=0;
 3072   
             loop26:
 3073   
             do {
 3074  136 
                 int alt26=2;
 3075  136 
                 switch ( input.LA(1) ) {
 3076   
                 case ABS:
 3077   
                 case BNODE:
 3078   
                 case BOUND:
 3079   
                 case CEIL:
 3080   
                 case COALESCE:
 3081   
                 case CONCAT:
 3082   
                 case CONTAINS:
 3083   
                 case DATATYPE:
 3084   
                 case DAY:
 3085   
                 case ENCODE_FOR_URI:
 3086   
                 case EXISTS:
 3087   
                 case FLOOR:
 3088   
                 case HOURS:
 3089   
                 case IF:
 3090   
                 case IRI:
 3091   
                 case IRI_REF:
 3092   
                 case ISBLANK:
 3093   
                 case ISIRI:
 3094   
                 case ISLITERAL:
 3095   
                 case ISNUMERIC:
 3096   
                 case ISURI:
 3097   
                 case LANG:
 3098   
                 case LANGMATCHES:
 3099   
                 case LCASE:
 3100   
                 case MD5:
 3101   
                 case MINUTES:
 3102   
                 case MONTH:
 3103   
                 case NOT:
 3104   
                 case NOW:
 3105   
                 case OPEN_BRACE:
 3106   
                 case PNAME_LN:
 3107   
                 case PNAME_NS:
 3108   
                 case RAND:
 3109   
                 case REGEX:
 3110   
                 case REPLACE:
 3111   
                 case ROUND:
 3112   
                 case SAMETERM:
 3113   
                 case SECONDS:
 3114   
                 case SHA1:
 3115   
                 case SHA224:
 3116   
                 case SHA256:
 3117   
                 case SHA384:
 3118   
                 case SHA512:
 3119   
                 case STR:
 3120   
                 case STRAFTER:
 3121   
                 case STRBEFORE:
 3122   
                 case STRDT:
 3123   
                 case STRENDS:
 3124   
                 case STRLANG:
 3125   
                 case STRLEN:
 3126   
                 case STRSTARTS:
 3127   
                 case SUBSTR:
 3128   
                 case TIMEZONE:
 3129   
                 case TZ:
 3130   
                 case UCASE:
 3131   
                 case URI:
 3132   
                 case VAR1:
 3133   
                 case VAR2:
 3134   
                 case YEAR:
 3135   
                     {
 3136  70 
                     alt26=1;
 3137   
                     }
 3138   
                     break;
 3139   
 
 3140   
                 }
 3141   
 
 3142  136 
                 switch (alt26) {
 3143   
                     case 1 :
 3144   
                         // com\\googlecode\\sparkleg\\Sparql.g:138:16: groupCondition
 3145   
                         {
 3146  70 
                         pushFollow(FOLLOW_groupCondition_in_groupClause836);
 3147  70 
                         groupCondition68=groupCondition();
 3148   
 
 3149  70 
                         state._fsp--;
 3150   
 
 3151  70 
                         stream_groupCondition.add(groupCondition68.getTree());
 3152   
 
 3153   
                         }
 3154  70 
                         break;
 3155   
 
 3156   
                     default :
 3157  66 
                         if ( cnt26 >= 1 ) break loop26;
 3158  0 
                         EarlyExitException eee =
 3159   
                             new EarlyExitException(26, input);
 3160  0 
                         throw eee;
 3161   
                 }
 3162  70 
                 cnt26++;
 3163  70 
             } while (true);
 3164   
 
 3165   
 
 3166   
             // AST REWRITE
 3167   
             // elements: groupCondition
 3168   
             // token labels:
 3169   
             // rule labels: retval
 3170   
             // token list labels:
 3171   
             // rule list labels:
 3172   
             // wildcard labels:
 3173  66 
             retval.tree = root_0;
 3174  66 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3175   
 
 3176  66 
             root_0 = (Object)adaptor.nil();
 3177   
             // 138:32: -> ^( GROUP_BY ( groupCondition )+ )
 3178   
             {
 3179   
                 // com\\googlecode\\sparkleg\\Sparql.g:138:35: ^( GROUP_BY ( groupCondition )+ )
 3180   
                 {
 3181  66 
                 Object root_1 = (Object)adaptor.nil();
 3182  66 
                 root_1 = (Object)adaptor.becomeRoot(
 3183   
                 (Object)adaptor.create(GROUP_BY, "GROUP_BY")
 3184   
                 , root_1);
 3185   
 
 3186  66 
                 if ( !(stream_groupCondition.hasNext()) ) {
 3187  0 
                     throw new RewriteEarlyExitException();
 3188   
                 }
 3189  136 
                 while ( stream_groupCondition.hasNext() ) {
 3190  70 
                     adaptor.addChild(root_1, stream_groupCondition.nextTree());
 3191   
 
 3192   
                 }
 3193  66 
                 stream_groupCondition.reset();
 3194   
 
 3195  66 
                 adaptor.addChild(root_0, root_1);
 3196   
                 }
 3197   
 
 3198   
             }
 3199   
 
 3200   
 
 3201  66 
             retval.tree = root_0;
 3202   
 
 3203   
             }
 3204   
 
 3205  66 
             retval.stop = input.LT(-1);
 3206   
 
 3207   
 
 3208  66 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3209  66 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3210   
 
 3211   
         }
 3212  0 
         catch (RecognitionException re) {
 3213  0 
             reportError(re);
 3214  0 
             recover(input,re);
 3215  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3216   
 
 3217   
         }
 3218   
 
 3219  0 
         finally {
 3220   
                 // do for sure before leaving
 3221  66 
         }
 3222  66 
         return retval;
 3223   
     }
 3224   
     // $ANTLR end "groupClause"
 3225   
 
 3226   
 
 3227  70 
     public static class groupCondition_return extends ParserRuleReturnScope {
 3228   
         Object tree;
 3229  70 
         public Object getTree() { return tree; }
 3230   
     };
 3231   
 
 3232   
 
 3233   
     // $ANTLR start "groupCondition"
 3234   
     // com\\googlecode\\sparkleg\\Sparql.g:141:1: groupCondition : ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) );
 3235   
     public final SparqlParser.groupCondition_return groupCondition() throws RecognitionException {
 3236  70 
         SparqlParser.groupCondition_return retval = new SparqlParser.groupCondition_return();
 3237  70 
         retval.start = input.LT(1);
 3238   
 
 3239   
 
 3240  70 
         Object root_0 = null;
 3241   
 
 3242  70 
         Token OPEN_BRACE71=null;
 3243  70 
         Token AS73=null;
 3244  70 
         Token CLOSE_BRACE75=null;
 3245  70 
         SparqlParser.builtInCall_return builtInCall69 =null;
 3246   
 
 3247  70 
         SparqlParser.functionCall_return functionCall70 =null;
 3248   
 
 3249  70 
         SparqlParser.expression_return expression72 =null;
 3250   
 
 3251  70 
         SparqlParser.var_return var74 =null;
 3252   
 
 3253  70 
         SparqlParser.var_return var76 =null;
 3254   
 
 3255   
 
 3256  70 
         Object OPEN_BRACE71_tree=null;
 3257  70 
         Object AS73_tree=null;
 3258  70 
         Object CLOSE_BRACE75_tree=null;
 3259  70 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 3260  70 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 3261  70 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 3262  70 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 3263  70 
         RewriteRuleSubtreeStream stream_functionCall=new RewriteRuleSubtreeStream(adaptor,"rule functionCall");
 3264  70 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 3265  70 
         RewriteRuleSubtreeStream stream_builtInCall=new RewriteRuleSubtreeStream(adaptor,"rule builtInCall");
 3266   
         try {
 3267   
             // com\\googlecode\\sparkleg\\Sparql.g:142:5: ( builtInCall -> ^( GROUP_CONDITION builtInCall ) | functionCall -> ^( GROUP_CONDITION functionCall ) | OPEN_BRACE expression ( AS var )? CLOSE_BRACE -> ^( GROUP_CONDITION expression ( var )? ) | var -> ^( GROUP_CONDITION var ) )
 3268  70 
             int alt28=4;
 3269  70 
             switch ( input.LA(1) ) {
 3270   
             case ABS:
 3271   
             case BNODE:
 3272   
             case BOUND:
 3273   
             case CEIL:
 3274   
             case COALESCE:
 3275   
             case CONCAT:
 3276   
             case CONTAINS:
 3277   
             case DATATYPE:
 3278   
             case DAY:
 3279   
             case ENCODE_FOR_URI:
 3280   
             case EXISTS:
 3281   
             case FLOOR:
 3282   
             case HOURS:
 3283   
             case IF:
 3284   
             case IRI:
 3285   
             case ISBLANK:
 3286   
             case ISIRI:
 3287   
             case ISLITERAL:
 3288   
             case ISNUMERIC:
 3289   
             case ISURI:
 3290   
             case LANG:
 3291   
             case LANGMATCHES:
 3292   
             case LCASE:
 3293   
             case MD5:
 3294   
             case MINUTES:
 3295   
             case MONTH:
 3296   
             case NOT:
 3297   
             case NOW:
 3298   
             case RAND:
 3299   
             case REGEX:
 3300   
             case REPLACE:
 3301   
             case ROUND:
 3302   
             case SAMETERM:
 3303   
             case SECONDS:
 3304   
             case SHA1:
 3305   
             case SHA224:
 3306   
             case SHA256:
 3307   
             case SHA384:
 3308   
             case SHA512:
 3309   
             case STR:
 3310   
             case STRAFTER:
 3311   
             case STRBEFORE:
 3312   
             case STRDT:
 3313   
             case STRENDS:
 3314   
             case STRLANG:
 3315   
             case STRLEN:
 3316   
             case STRSTARTS:
 3317   
             case SUBSTR:
 3318   
             case TIMEZONE:
 3319   
             case TZ:
 3320   
             case UCASE:
 3321   
             case URI:
 3322   
             case YEAR:
 3323   
                 {
 3324  0 
                 alt28=1;
 3325   
                 }
 3326  0 
                 break;
 3327   
             case IRI_REF:
 3328   
             case PNAME_LN:
 3329   
             case PNAME_NS:
 3330   
                 {
 3331  0 
                 alt28=2;
 3332   
                 }
 3333  0 
                 break;
 3334   
             case OPEN_BRACE:
 3335   
                 {
 3336  12 
                 alt28=3;
 3337   
                 }
 3338  12 
                 break;
 3339   
             case VAR1:
 3340   
             case VAR2:
 3341   
                 {
 3342  58 
                 alt28=4;
 3343   
                 }
 3344  58 
                 break;
 3345   
             default:
 3346  0 
                 NoViableAltException nvae =
 3347   
                     new NoViableAltException("", 28, 0, input);
 3348   
 
 3349  0 
                 throw nvae;
 3350   
 
 3351   
             }
 3352   
 
 3353  70 
             switch (alt28) {
 3354   
                 case 1 :
 3355   
                     // com\\googlecode\\sparkleg\\Sparql.g:142:7: builtInCall
 3356   
                     {
 3357  0 
                     pushFollow(FOLLOW_builtInCall_in_groupCondition870);
 3358  0 
                     builtInCall69=builtInCall();
 3359   
 
 3360  0 
                     state._fsp--;
 3361   
 
 3362  0 
                     stream_builtInCall.add(builtInCall69.getTree());
 3363   
 
 3364   
                     // AST REWRITE
 3365   
                     // elements: builtInCall
 3366   
                     // token labels:
 3367   
                     // rule labels: retval
 3368   
                     // token list labels:
 3369   
                     // rule list labels:
 3370   
                     // wildcard labels:
 3371  0 
                     retval.tree = root_0;
 3372  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3373   
 
 3374  0 
                     root_0 = (Object)adaptor.nil();
 3375   
                     // 142:19: -> ^( GROUP_CONDITION builtInCall )
 3376   
                     {
 3377   
                         // com\\googlecode\\sparkleg\\Sparql.g:142:22: ^( GROUP_CONDITION builtInCall )
 3378   
                         {
 3379  0 
                         Object root_1 = (Object)adaptor.nil();
 3380  0 
                         root_1 = (Object)adaptor.becomeRoot(
 3381   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3382   
                         , root_1);
 3383   
 
 3384  0 
                         adaptor.addChild(root_1, stream_builtInCall.nextTree());
 3385   
 
 3386  0 
                         adaptor.addChild(root_0, root_1);
 3387   
                         }
 3388   
 
 3389   
                     }
 3390   
 
 3391   
 
 3392  0 
                     retval.tree = root_0;
 3393   
 
 3394   
                     }
 3395  0 
                     break;
 3396   
                 case 2 :
 3397   
                     // com\\googlecode\\sparkleg\\Sparql.g:143:7: functionCall
 3398   
                     {
 3399  0 
                     pushFollow(FOLLOW_functionCall_in_groupCondition886);
 3400  0 
                     functionCall70=functionCall();
 3401   
 
 3402  0 
                     state._fsp--;
 3403   
 
 3404  0 
                     stream_functionCall.add(functionCall70.getTree());
 3405   
 
 3406   
                     // AST REWRITE
 3407   
                     // elements: functionCall
 3408   
                     // token labels:
 3409   
                     // rule labels: retval
 3410   
                     // token list labels:
 3411   
                     // rule list labels:
 3412   
                     // wildcard labels:
 3413  0 
                     retval.tree = root_0;
 3414  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3415   
 
 3416  0 
                     root_0 = (Object)adaptor.nil();
 3417   
                     // 143:20: -> ^( GROUP_CONDITION functionCall )
 3418   
                     {
 3419   
                         // com\\googlecode\\sparkleg\\Sparql.g:143:23: ^( GROUP_CONDITION functionCall )
 3420   
                         {
 3421  0 
                         Object root_1 = (Object)adaptor.nil();
 3422  0 
                         root_1 = (Object)adaptor.becomeRoot(
 3423   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3424   
                         , root_1);
 3425   
 
 3426  0 
                         adaptor.addChild(root_1, stream_functionCall.nextTree());
 3427   
 
 3428  0 
                         adaptor.addChild(root_0, root_1);
 3429   
                         }
 3430   
 
 3431   
                     }
 3432   
 
 3433   
 
 3434  0 
                     retval.tree = root_0;
 3435   
 
 3436   
                     }
 3437  0 
                     break;
 3438   
                 case 3 :
 3439   
                     // com\\googlecode\\sparkleg\\Sparql.g:144:7: OPEN_BRACE expression ( AS var )? CLOSE_BRACE
 3440   
                     {
 3441  12 
                     OPEN_BRACE71=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_groupCondition902);
 3442  12 
                     stream_OPEN_BRACE.add(OPEN_BRACE71);
 3443   
 
 3444   
 
 3445  12 
                     pushFollow(FOLLOW_expression_in_groupCondition904);
 3446  12 
                     expression72=expression();
 3447   
 
 3448  12 
                     state._fsp--;
 3449   
 
 3450  12 
                     stream_expression.add(expression72.getTree());
 3451   
 
 3452   
                     // com\\googlecode\\sparkleg\\Sparql.g:144:29: ( AS var )?
 3453  12 
                     int alt27=2;
 3454  12 
                     switch ( input.LA(1) ) {
 3455   
                         case AS:
 3456   
                             {
 3457  4 
                             alt27=1;
 3458   
                             }
 3459   
                             break;
 3460   
                     }
 3461   
 
 3462  12 
                     switch (alt27) {
 3463   
                         case 1 :
 3464   
                             // com\\googlecode\\sparkleg\\Sparql.g:144:30: AS var
 3465   
                             {
 3466  4 
                             AS73=(Token)match(input,AS,FOLLOW_AS_in_groupCondition907);
 3467  4 
                             stream_AS.add(AS73);
 3468   
 
 3469   
 
 3470  4 
                             pushFollow(FOLLOW_var_in_groupCondition909);
 3471  4 
                             var74=var();
 3472   
 
 3473  4 
                             state._fsp--;
 3474   
 
 3475  4 
                             stream_var.add(var74.getTree());
 3476   
 
 3477   
                             }
 3478   
                             break;
 3479   
 
 3480   
                     }
 3481   
 
 3482   
 
 3483  12 
                     CLOSE_BRACE75=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_groupCondition913);
 3484  12 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE75);
 3485   
 
 3486   
 
 3487   
                     // AST REWRITE
 3488   
                     // elements: expression, var
 3489   
                     // token labels:
 3490   
                     // rule labels: retval
 3491   
                     // token list labels:
 3492   
                     // rule list labels:
 3493   
                     // wildcard labels:
 3494  12 
                     retval.tree = root_0;
 3495  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3496   
 
 3497  12 
                     root_0 = (Object)adaptor.nil();
 3498   
                     // 144:51: -> ^( GROUP_CONDITION expression ( var )? )
 3499   
                     {
 3500   
                         // com\\googlecode\\sparkleg\\Sparql.g:144:54: ^( GROUP_CONDITION expression ( var )? )
 3501   
                         {
 3502  12 
                         Object root_1 = (Object)adaptor.nil();
 3503  12 
                         root_1 = (Object)adaptor.becomeRoot(
 3504   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3505   
                         , root_1);
 3506   
 
 3507  12 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 3508   
 
 3509   
                         // com\\googlecode\\sparkleg\\Sparql.g:144:83: ( var )?
 3510  12 
                         if ( stream_var.hasNext() ) {
 3511  4 
                             adaptor.addChild(root_1, stream_var.nextTree());
 3512   
 
 3513   
                         }
 3514  12 
                         stream_var.reset();
 3515   
 
 3516  12 
                         adaptor.addChild(root_0, root_1);
 3517   
                         }
 3518   
 
 3519   
                     }
 3520   
 
 3521   
 
 3522  12 
                     retval.tree = root_0;
 3523   
 
 3524   
                     }
 3525  12 
                     break;
 3526   
                 case 4 :
 3527   
                     // com\\googlecode\\sparkleg\\Sparql.g:145:7: var
 3528   
                     {
 3529  58 
                     pushFollow(FOLLOW_var_in_groupCondition932);
 3530  58 
                     var76=var();
 3531   
 
 3532  58 
                     state._fsp--;
 3533   
 
 3534  58 
                     stream_var.add(var76.getTree());
 3535   
 
 3536   
                     // AST REWRITE
 3537   
                     // elements: var
 3538   
                     // token labels:
 3539   
                     // rule labels: retval
 3540   
                     // token list labels:
 3541   
                     // rule list labels:
 3542   
                     // wildcard labels:
 3543  58 
                     retval.tree = root_0;
 3544  58 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3545   
 
 3546  58 
                     root_0 = (Object)adaptor.nil();
 3547   
                     // 145:11: -> ^( GROUP_CONDITION var )
 3548   
                     {
 3549   
                         // com\\googlecode\\sparkleg\\Sparql.g:145:14: ^( GROUP_CONDITION var )
 3550   
                         {
 3551  58 
                         Object root_1 = (Object)adaptor.nil();
 3552  58 
                         root_1 = (Object)adaptor.becomeRoot(
 3553   
                         (Object)adaptor.create(GROUP_CONDITION, "GROUP_CONDITION")
 3554   
                         , root_1);
 3555   
 
 3556  58 
                         adaptor.addChild(root_1, stream_var.nextTree());
 3557   
 
 3558  58 
                         adaptor.addChild(root_0, root_1);
 3559   
                         }
 3560   
 
 3561   
                     }
 3562   
 
 3563   
 
 3564  58 
                     retval.tree = root_0;
 3565   
 
 3566   
                     }
 3567   
                     break;
 3568   
 
 3569   
             }
 3570  70 
             retval.stop = input.LT(-1);
 3571   
 
 3572   
 
 3573  70 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3574  70 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3575   
 
 3576   
         }
 3577  0 
         catch (RecognitionException re) {
 3578  0 
             reportError(re);
 3579  0 
             recover(input,re);
 3580  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3581   
 
 3582   
         }
 3583   
 
 3584  0 
         finally {
 3585   
                 // do for sure before leaving
 3586  70 
         }
 3587  70 
         return retval;
 3588   
     }
 3589   
     // $ANTLR end "groupCondition"
 3590   
 
 3591   
 
 3592  16 
     public static class havingClause_return extends ParserRuleReturnScope {
 3593   
         Object tree;
 3594  16 
         public Object getTree() { return tree; }
 3595   
     };
 3596   
 
 3597   
 
 3598   
     // $ANTLR start "havingClause"
 3599   
     // com\\googlecode\\sparkleg\\Sparql.g:148:1: havingClause : HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) ;
 3600   
     public final SparqlParser.havingClause_return havingClause() throws RecognitionException {
 3601  16 
         SparqlParser.havingClause_return retval = new SparqlParser.havingClause_return();
 3602  16 
         retval.start = input.LT(1);
 3603   
 
 3604   
 
 3605  16 
         Object root_0 = null;
 3606   
 
 3607  16 
         Token HAVING77=null;
 3608  16 
         SparqlParser.constraint_return constraint78 =null;
 3609   
 
 3610   
 
 3611  16 
         Object HAVING77_tree=null;
 3612  16 
         RewriteRuleTokenStream stream_HAVING=new RewriteRuleTokenStream(adaptor,"token HAVING");
 3613  16 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 3614   
         try {
 3615   
             // com\\googlecode\\sparkleg\\Sparql.g:149:5: ( HAVING ( constraint )+ -> ^( HAVING ( constraint )+ ) )
 3616   
             // com\\googlecode\\sparkleg\\Sparql.g:149:7: HAVING ( constraint )+
 3617   
             {
 3618  16 
             HAVING77=(Token)match(input,HAVING,FOLLOW_HAVING_in_havingClause961);
 3619  16 
             stream_HAVING.add(HAVING77);
 3620   
 
 3621   
 
 3622   
             // com\\googlecode\\sparkleg\\Sparql.g:149:14: ( constraint )+
 3623  16 
             int cnt29=0;
 3624   
             loop29:
 3625   
             do {
 3626  32 
                 int alt29=2;
 3627  32 
                 switch ( input.LA(1) ) {
 3628   
                 case ABS:
 3629   
                 case BNODE:
 3630   
                 case BOUND:
 3631   
                 case CEIL:
 3632   
                 case COALESCE:
 3633   
                 case CONCAT:
 3634   
                 case CONTAINS:
 3635   
                 case DATATYPE:
 3636   
                 case DAY:
 3637   
                 case ENCODE_FOR_URI:
 3638   
                 case EXISTS:
 3639   
                 case FLOOR:
 3640   
                 case HOURS:
 3641   
                 case IF:
 3642   
                 case IRI:
 3643   
                 case IRI_REF:
 3644   
                 case ISBLANK:
 3645   
                 case ISIRI:
 3646   
                 case ISLITERAL:
 3647   
                 case ISNUMERIC:
 3648   
                 case ISURI:
 3649   
                 case LANG:
 3650   
                 case LANGMATCHES:
 3651   
                 case LCASE:
 3652   
                 case MD5:
 3653   
                 case MINUTES:
 3654   
                 case MONTH:
 3655   
                 case NOT:
 3656   
                 case NOW:
 3657   
                 case OPEN_BRACE:
 3658   
                 case PNAME_LN:
 3659   
                 case PNAME_NS:
 3660   
                 case RAND:
 3661   
                 case REGEX:
 3662   
                 case REPLACE:
 3663   
                 case ROUND:
 3664   
                 case SAMETERM:
 3665   
                 case SECONDS:
 3666   
                 case SHA1:
 3667   
                 case SHA224:
 3668   
                 case SHA256:
 3669   
                 case SHA384:
 3670   
                 case SHA512:
 3671   
                 case STR:
 3672   
                 case STRAFTER:
 3673   
                 case STRBEFORE:
 3674   
                 case STRDT:
 3675   
                 case STRENDS:
 3676   
                 case STRLANG:
 3677   
                 case STRLEN:
 3678   
                 case STRSTARTS:
 3679   
                 case SUBSTR:
 3680   
                 case TIMEZONE:
 3681   
                 case TZ:
 3682   
                 case UCASE:
 3683   
                 case URI:
 3684   
                 case YEAR:
 3685   
                     {
 3686  16 
                     alt29=1;
 3687   
                     }
 3688   
                     break;
 3689   
 
 3690   
                 }
 3691   
 
 3692  32 
                 switch (alt29) {
 3693   
                     case 1 :
 3694   
                         // com\\googlecode\\sparkleg\\Sparql.g:149:14: constraint
 3695   
                         {
 3696  16 
                         pushFollow(FOLLOW_constraint_in_havingClause963);
 3697  16 
                         constraint78=constraint();
 3698   
 
 3699  16 
                         state._fsp--;
 3700   
 
 3701  16 
                         stream_constraint.add(constraint78.getTree());
 3702   
 
 3703   
                         }
 3704  16 
                         break;
 3705   
 
 3706   
                     default :
 3707  16 
                         if ( cnt29 >= 1 ) break loop29;
 3708  0 
                         EarlyExitException eee =
 3709   
                             new EarlyExitException(29, input);
 3710  0 
                         throw eee;
 3711   
                 }
 3712  16 
                 cnt29++;
 3713  16 
             } while (true);
 3714   
 
 3715   
 
 3716   
             // AST REWRITE
 3717   
             // elements: constraint, HAVING
 3718   
             // token labels:
 3719   
             // rule labels: retval
 3720   
             // token list labels:
 3721   
             // rule list labels:
 3722   
             // wildcard labels:
 3723  16 
             retval.tree = root_0;
 3724  16 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3725   
 
 3726  16 
             root_0 = (Object)adaptor.nil();
 3727   
             // 149:26: -> ^( HAVING ( constraint )+ )
 3728   
             {
 3729   
                 // com\\googlecode\\sparkleg\\Sparql.g:149:29: ^( HAVING ( constraint )+ )
 3730   
                 {
 3731  16 
                 Object root_1 = (Object)adaptor.nil();
 3732  16 
                 root_1 = (Object)adaptor.becomeRoot(
 3733   
                 stream_HAVING.nextNode()
 3734   
                 , root_1);
 3735   
 
 3736  16 
                 if ( !(stream_constraint.hasNext()) ) {
 3737  0 
                     throw new RewriteEarlyExitException();
 3738   
                 }
 3739  32 
                 while ( stream_constraint.hasNext() ) {
 3740  16 
                     adaptor.addChild(root_1, stream_constraint.nextTree());
 3741   
 
 3742   
                 }
 3743  16 
                 stream_constraint.reset();
 3744   
 
 3745  16 
                 adaptor.addChild(root_0, root_1);
 3746   
                 }
 3747   
 
 3748   
             }
 3749   
 
 3750   
 
 3751  16 
             retval.tree = root_0;
 3752   
 
 3753   
             }
 3754   
 
 3755  16 
             retval.stop = input.LT(-1);
 3756   
 
 3757   
 
 3758  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3759  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3760   
 
 3761   
         }
 3762  0 
         catch (RecognitionException re) {
 3763  0 
             reportError(re);
 3764  0 
             recover(input,re);
 3765  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3766   
 
 3767   
         }
 3768   
 
 3769  0 
         finally {
 3770   
                 // do for sure before leaving
 3771  16 
         }
 3772  16 
         return retval;
 3773   
     }
 3774   
     // $ANTLR end "havingClause"
 3775   
 
 3776   
 
 3777  134 
     public static class orderClause_return extends ParserRuleReturnScope {
 3778   
         Object tree;
 3779  134 
         public Object getTree() { return tree; }
 3780   
     };
 3781   
 
 3782   
 
 3783   
     // $ANTLR start "orderClause"
 3784   
     // com\\googlecode\\sparkleg\\Sparql.g:152:1: orderClause : ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) ;
 3785   
     public final SparqlParser.orderClause_return orderClause() throws RecognitionException {
 3786  134 
         SparqlParser.orderClause_return retval = new SparqlParser.orderClause_return();
 3787  134 
         retval.start = input.LT(1);
 3788   
 
 3789   
 
 3790  134 
         Object root_0 = null;
 3791   
 
 3792  134 
         Token ORDER79=null;
 3793  134 
         Token BY80=null;
 3794  134 
         SparqlParser.orderCondition_return orderCondition81 =null;
 3795   
 
 3796   
 
 3797  134 
         Object ORDER79_tree=null;
 3798  134 
         Object BY80_tree=null;
 3799  134 
         RewriteRuleTokenStream stream_BY=new RewriteRuleTokenStream(adaptor,"token BY");
 3800  134 
         RewriteRuleTokenStream stream_ORDER=new RewriteRuleTokenStream(adaptor,"token ORDER");
 3801  134 
         RewriteRuleSubtreeStream stream_orderCondition=new RewriteRuleSubtreeStream(adaptor,"rule orderCondition");
 3802   
         try {
 3803   
             // com\\googlecode\\sparkleg\\Sparql.g:153:5: ( ORDER BY ( orderCondition )+ -> ^( ORDER_BY ( orderCondition )+ ) )
 3804   
             // com\\googlecode\\sparkleg\\Sparql.g:153:7: ORDER BY ( orderCondition )+
 3805   
             {
 3806  134 
             ORDER79=(Token)match(input,ORDER,FOLLOW_ORDER_in_orderClause995);
 3807  134 
             stream_ORDER.add(ORDER79);
 3808   
 
 3809   
 
 3810  134 
             BY80=(Token)match(input,BY,FOLLOW_BY_in_orderClause997);
 3811  134 
             stream_BY.add(BY80);
 3812   
 
 3813   
 
 3814   
             // com\\googlecode\\sparkleg\\Sparql.g:153:16: ( orderCondition )+
 3815  134 
             int cnt30=0;
 3816   
             loop30:
 3817   
             do {
 3818  316 
                 int alt30=2;
 3819  316 
                 switch ( input.LA(1) ) {
 3820   
                 case ABS:
 3821   
                 case ASC:
 3822   
                 case BNODE:
 3823   
                 case BOUND:
 3824   
                 case CEIL:
 3825   
                 case COALESCE:
 3826   
                 case CONCAT:
 3827   
                 case CONTAINS:
 3828   
                 case DATATYPE:
 3829   
                 case DAY:
 3830   
                 case DESC:
 3831   
                 case ENCODE_FOR_URI:
 3832   
                 case EXISTS:
 3833   
                 case FLOOR:
 3834   
                 case HOURS:
 3835   
                 case IF:
 3836   
                 case IRI:
 3837   
                 case IRI_REF:
 3838   
                 case ISBLANK:
 3839   
                 case ISIRI:
 3840   
                 case ISLITERAL:
 3841   
                 case ISNUMERIC:
 3842   
                 case ISURI:
 3843   
                 case LANG:
 3844   
                 case LANGMATCHES:
 3845   
                 case LCASE:
 3846   
                 case MD5:
 3847   
                 case MINUTES:
 3848   
                 case MONTH:
 3849   
                 case NOT:
 3850   
                 case NOW:
 3851   
                 case OPEN_BRACE:
 3852   
                 case PNAME_LN:
 3853   
                 case PNAME_NS:
 3854   
                 case RAND:
 3855   
                 case REGEX:
 3856   
                 case REPLACE:
 3857   
                 case ROUND:
 3858   
                 case SAMETERM:
 3859   
                 case SECONDS:
 3860   
                 case SHA1:
 3861   
                 case SHA224:
 3862   
                 case SHA256:
 3863   
                 case SHA384:
 3864   
                 case SHA512:
 3865   
                 case STR:
 3866   
                 case STRAFTER:
 3867   
                 case STRBEFORE:
 3868   
                 case STRDT:
 3869   
                 case STRENDS:
 3870   
                 case STRLANG:
 3871   
                 case STRLEN:
 3872   
                 case STRSTARTS:
 3873   
                 case SUBSTR:
 3874   
                 case TIMEZONE:
 3875   
                 case TZ:
 3876   
                 case UCASE:
 3877   
                 case URI:
 3878   
                 case VAR1:
 3879   
                 case VAR2:
 3880   
                 case YEAR:
 3881   
                     {
 3882  182 
                     alt30=1;
 3883   
                     }
 3884   
                     break;
 3885   
 
 3886   
                 }
 3887   
 
 3888  316 
                 switch (alt30) {
 3889   
                     case 1 :
 3890   
                         // com\\googlecode\\sparkleg\\Sparql.g:153:16: orderCondition
 3891   
                         {
 3892  182 
                         pushFollow(FOLLOW_orderCondition_in_orderClause999);
 3893  182 
                         orderCondition81=orderCondition();
 3894   
 
 3895  182 
                         state._fsp--;
 3896   
 
 3897  182 
                         stream_orderCondition.add(orderCondition81.getTree());
 3898   
 
 3899   
                         }
 3900  182 
                         break;
 3901   
 
 3902   
                     default :
 3903  134 
                         if ( cnt30 >= 1 ) break loop30;
 3904  0 
                         EarlyExitException eee =
 3905   
                             new EarlyExitException(30, input);
 3906  0 
                         throw eee;
 3907   
                 }
 3908  182 
                 cnt30++;
 3909  182 
             } while (true);
 3910   
 
 3911   
 
 3912   
             // AST REWRITE
 3913   
             // elements: orderCondition
 3914   
             // token labels:
 3915   
             // rule labels: retval
 3916   
             // token list labels:
 3917   
             // rule list labels:
 3918   
             // wildcard labels:
 3919  134 
             retval.tree = root_0;
 3920  134 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 3921   
 
 3922  134 
             root_0 = (Object)adaptor.nil();
 3923   
             // 153:32: -> ^( ORDER_BY ( orderCondition )+ )
 3924   
             {
 3925   
                 // com\\googlecode\\sparkleg\\Sparql.g:153:35: ^( ORDER_BY ( orderCondition )+ )
 3926   
                 {
 3927  134 
                 Object root_1 = (Object)adaptor.nil();
 3928  134 
                 root_1 = (Object)adaptor.becomeRoot(
 3929   
                 (Object)adaptor.create(ORDER_BY, "ORDER_BY")
 3930   
                 , root_1);
 3931   
 
 3932  134 
                 if ( !(stream_orderCondition.hasNext()) ) {
 3933  0 
                     throw new RewriteEarlyExitException();
 3934   
                 }
 3935  316 
                 while ( stream_orderCondition.hasNext() ) {
 3936  182 
                     adaptor.addChild(root_1, stream_orderCondition.nextTree());
 3937   
 
 3938   
                 }
 3939  134 
                 stream_orderCondition.reset();
 3940   
 
 3941  134 
                 adaptor.addChild(root_0, root_1);
 3942   
                 }
 3943   
 
 3944   
             }
 3945   
 
 3946   
 
 3947  134 
             retval.tree = root_0;
 3948   
 
 3949   
             }
 3950   
 
 3951  134 
             retval.stop = input.LT(-1);
 3952   
 
 3953   
 
 3954  134 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 3955  134 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 3956   
 
 3957   
         }
 3958  0 
         catch (RecognitionException re) {
 3959  0 
             reportError(re);
 3960  0 
             recover(input,re);
 3961  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 3962   
 
 3963   
         }
 3964   
 
 3965  0 
         finally {
 3966   
                 // do for sure before leaving
 3967  134 
         }
 3968  134 
         return retval;
 3969   
     }
 3970   
     // $ANTLR end "orderClause"
 3971   
 
 3972   
 
 3973  182 
     public static class orderCondition_return extends ParserRuleReturnScope {
 3974   
         Object tree;
 3975  182 
         public Object getTree() { return tree; }
 3976   
     };
 3977   
 
 3978   
 
 3979   
     // $ANTLR start "orderCondition"
 3980   
     // com\\googlecode\\sparkleg\\Sparql.g:156:1: orderCondition : ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) );
 3981   
     public final SparqlParser.orderCondition_return orderCondition() throws RecognitionException {
 3982  182 
         SparqlParser.orderCondition_return retval = new SparqlParser.orderCondition_return();
 3983  182 
         retval.start = input.LT(1);
 3984   
 
 3985   
 
 3986  182 
         Object root_0 = null;
 3987   
 
 3988  182 
         Token ASC82=null;
 3989  182 
         Token DESC84=null;
 3990  182 
         SparqlParser.brackettedExpression_return brackettedExpression83 =null;
 3991   
 
 3992  182 
         SparqlParser.brackettedExpression_return brackettedExpression85 =null;
 3993   
 
 3994  182 
         SparqlParser.constraint_return constraint86 =null;
 3995   
 
 3996  182 
         SparqlParser.var_return var87 =null;
 3997   
 
 3998   
 
 3999  182 
         Object ASC82_tree=null;
 4000  182 
         Object DESC84_tree=null;
 4001  182 
         RewriteRuleTokenStream stream_DESC=new RewriteRuleTokenStream(adaptor,"token DESC");
 4002  182 
         RewriteRuleTokenStream stream_ASC=new RewriteRuleTokenStream(adaptor,"token ASC");
 4003  182 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4004  182 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 4005  182 
         RewriteRuleSubtreeStream stream_brackettedExpression=new RewriteRuleSubtreeStream(adaptor,"rule brackettedExpression");
 4006   
         try {
 4007   
             // com\\googlecode\\sparkleg\\Sparql.g:157:5: ( ASC brackettedExpression -> ^( ORDER_CONDITION ASC brackettedExpression ) | DESC brackettedExpression -> ^( ORDER_CONDITION DESC brackettedExpression ) | constraint -> ^( ORDER_CONDITION constraint ) | var -> ^( ORDER_CONDITION var ) )
 4008  182 
             int alt31=4;
 4009  182 
             switch ( input.LA(1) ) {
 4010   
             case ASC:
 4011   
                 {
 4012  10 
                 alt31=1;
 4013   
                 }
 4014  10 
                 break;
 4015   
             case DESC:
 4016   
                 {
 4017  30 
                 alt31=2;
 4018   
                 }
 4019  30 
                 break;
 4020   
             case ABS:
 4021   
             case BNODE:
 4022   
             case BOUND:
 4023   
             case CEIL:
 4024   
             case COALESCE:
 4025   
             case CONCAT:
 4026   
             case CONTAINS:
 4027   
             case DATATYPE:
 4028   
             case DAY:
 4029   
             case ENCODE_FOR_URI:
 4030   
             case EXISTS:
 4031   
             case FLOOR:
 4032   
             case HOURS:
 4033   
             case IF:
 4034   
             case IRI:
 4035   
             case IRI_REF:
 4036   
             case ISBLANK:
 4037   
             case ISIRI:
 4038   
             case ISLITERAL:
 4039   
             case ISNUMERIC:
 4040   
             case ISURI:
 4041   
             case LANG:
 4042   
             case LANGMATCHES:
 4043   
             case LCASE:
 4044   
             case MD5:
 4045   
             case MINUTES:
 4046   
             case MONTH:
 4047   
             case NOT:
 4048   
             case NOW:
 4049   
             case OPEN_BRACE:
 4050   
             case PNAME_LN:
 4051   
             case PNAME_NS:
 4052   
             case RAND:
 4053   
             case REGEX:
 4054   
             case REPLACE:
 4055   
             case ROUND:
 4056   
             case SAMETERM:
 4057   
             case SECONDS:
 4058   
             case SHA1:
 4059   
             case SHA224:
 4060   
             case SHA256:
 4061   
             case SHA384:
 4062   
             case SHA512:
 4063   
             case STR:
 4064   
             case STRAFTER:
 4065   
             case STRBEFORE:
 4066   
             case STRDT:
 4067   
             case STRENDS:
 4068   
             case STRLANG:
 4069   
             case STRLEN:
 4070   
             case STRSTARTS:
 4071   
             case SUBSTR:
 4072   
             case TIMEZONE:
 4073   
             case TZ:
 4074   
             case UCASE:
 4075   
             case URI:
 4076   
             case YEAR:
 4077   
                 {
 4078  12 
                 alt31=3;
 4079   
                 }
 4080  12 
                 break;
 4081   
             case VAR1:
 4082   
             case VAR2:
 4083   
                 {
 4084  130 
                 alt31=4;
 4085   
                 }
 4086  130 
                 break;
 4087   
             default:
 4088  0 
                 NoViableAltException nvae =
 4089   
                     new NoViableAltException("", 31, 0, input);
 4090   
 
 4091  0 
                 throw nvae;
 4092   
 
 4093   
             }
 4094   
 
 4095  182 
             switch (alt31) {
 4096   
                 case 1 :
 4097   
                     // com\\googlecode\\sparkleg\\Sparql.g:157:7: ASC brackettedExpression
 4098   
                     {
 4099  10 
                     ASC82=(Token)match(input,ASC,FOLLOW_ASC_in_orderCondition1026);
 4100  10 
                     stream_ASC.add(ASC82);
 4101   
 
 4102   
 
 4103  10 
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1028);
 4104  10 
                     brackettedExpression83=brackettedExpression();
 4105   
 
 4106  10 
                     state._fsp--;
 4107   
 
 4108  10 
                     stream_brackettedExpression.add(brackettedExpression83.getTree());
 4109   
 
 4110   
                     // AST REWRITE
 4111   
                     // elements: brackettedExpression, ASC
 4112   
                     // token labels:
 4113   
                     // rule labels: retval
 4114   
                     // token list labels:
 4115   
                     // rule list labels:
 4116   
                     // wildcard labels:
 4117  10 
                     retval.tree = root_0;
 4118  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4119   
 
 4120  10 
                     root_0 = (Object)adaptor.nil();
 4121   
                     // 157:32: -> ^( ORDER_CONDITION ASC brackettedExpression )
 4122   
                     {
 4123   
                         // com\\googlecode\\sparkleg\\Sparql.g:157:35: ^( ORDER_CONDITION ASC brackettedExpression )
 4124   
                         {
 4125  10 
                         Object root_1 = (Object)adaptor.nil();
 4126  10 
                         root_1 = (Object)adaptor.becomeRoot(
 4127   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4128   
                         , root_1);
 4129   
 
 4130  10 
                         adaptor.addChild(root_1,
 4131   
                         stream_ASC.nextNode()
 4132   
                         );
 4133   
 
 4134  10 
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4135   
 
 4136  10 
                         adaptor.addChild(root_0, root_1);
 4137   
                         }
 4138   
 
 4139   
                     }
 4140   
 
 4141   
 
 4142  10 
                     retval.tree = root_0;
 4143   
 
 4144   
                     }
 4145  10 
                     break;
 4146   
                 case 2 :
 4147   
                     // com\\googlecode\\sparkleg\\Sparql.g:158:7: DESC brackettedExpression
 4148   
                     {
 4149  30 
                     DESC84=(Token)match(input,DESC,FOLLOW_DESC_in_orderCondition1046);
 4150  30 
                     stream_DESC.add(DESC84);
 4151   
 
 4152   
 
 4153  30 
                     pushFollow(FOLLOW_brackettedExpression_in_orderCondition1048);
 4154  30 
                     brackettedExpression85=brackettedExpression();
 4155   
 
 4156  30 
                     state._fsp--;
 4157   
 
 4158  30 
                     stream_brackettedExpression.add(brackettedExpression85.getTree());
 4159   
 
 4160   
                     // AST REWRITE
 4161   
                     // elements: brackettedExpression, DESC
 4162   
                     // token labels:
 4163   
                     // rule labels: retval
 4164   
                     // token list labels:
 4165   
                     // rule list labels:
 4166   
                     // wildcard labels:
 4167  30 
                     retval.tree = root_0;
 4168  30 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4169   
 
 4170  30 
                     root_0 = (Object)adaptor.nil();
 4171   
                     // 158:33: -> ^( ORDER_CONDITION DESC brackettedExpression )
 4172   
                     {
 4173   
                         // com\\googlecode\\sparkleg\\Sparql.g:158:36: ^( ORDER_CONDITION DESC brackettedExpression )
 4174   
                         {
 4175  30 
                         Object root_1 = (Object)adaptor.nil();
 4176  30 
                         root_1 = (Object)adaptor.becomeRoot(
 4177   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4178   
                         , root_1);
 4179   
 
 4180  30 
                         adaptor.addChild(root_1,
 4181   
                         stream_DESC.nextNode()
 4182   
                         );
 4183   
 
 4184  30 
                         adaptor.addChild(root_1, stream_brackettedExpression.nextTree());
 4185   
 
 4186  30 
                         adaptor.addChild(root_0, root_1);
 4187   
                         }
 4188   
 
 4189   
                     }
 4190   
 
 4191   
 
 4192  30 
                     retval.tree = root_0;
 4193   
 
 4194   
                     }
 4195  30 
                     break;
 4196   
                 case 3 :
 4197   
                     // com\\googlecode\\sparkleg\\Sparql.g:159:7: constraint
 4198   
                     {
 4199  12 
                     pushFollow(FOLLOW_constraint_in_orderCondition1066);
 4200  12 
                     constraint86=constraint();
 4201   
 
 4202  12 
                     state._fsp--;
 4203   
 
 4204  12 
                     stream_constraint.add(constraint86.getTree());
 4205   
 
 4206   
                     // AST REWRITE
 4207   
                     // elements: constraint
 4208   
                     // token labels:
 4209   
                     // rule labels: retval
 4210   
                     // token list labels:
 4211   
                     // rule list labels:
 4212   
                     // wildcard labels:
 4213  12 
                     retval.tree = root_0;
 4214  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4215   
 
 4216  12 
                     root_0 = (Object)adaptor.nil();
 4217   
                     // 159:18: -> ^( ORDER_CONDITION constraint )
 4218   
                     {
 4219   
                         // com\\googlecode\\sparkleg\\Sparql.g:159:21: ^( ORDER_CONDITION constraint )
 4220   
                         {
 4221  12 
                         Object root_1 = (Object)adaptor.nil();
 4222  12 
                         root_1 = (Object)adaptor.becomeRoot(
 4223   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4224   
                         , root_1);
 4225   
 
 4226  12 
                         adaptor.addChild(root_1, stream_constraint.nextTree());
 4227   
 
 4228  12 
                         adaptor.addChild(root_0, root_1);
 4229   
                         }
 4230   
 
 4231   
                     }
 4232   
 
 4233   
 
 4234  12 
                     retval.tree = root_0;
 4235   
 
 4236   
                     }
 4237  12 
                     break;
 4238   
                 case 4 :
 4239   
                     // com\\googlecode\\sparkleg\\Sparql.g:160:7: var
 4240   
                     {
 4241  130 
                     pushFollow(FOLLOW_var_in_orderCondition1082);
 4242  130 
                     var87=var();
 4243   
 
 4244  130 
                     state._fsp--;
 4245   
 
 4246  130 
                     stream_var.add(var87.getTree());
 4247   
 
 4248   
                     // AST REWRITE
 4249   
                     // elements: var
 4250   
                     // token labels:
 4251   
                     // rule labels: retval
 4252   
                     // token list labels:
 4253   
                     // rule list labels:
 4254   
                     // wildcard labels:
 4255  130 
                     retval.tree = root_0;
 4256  130 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4257   
 
 4258  130 
                     root_0 = (Object)adaptor.nil();
 4259   
                     // 160:11: -> ^( ORDER_CONDITION var )
 4260   
                     {
 4261   
                         // com\\googlecode\\sparkleg\\Sparql.g:160:14: ^( ORDER_CONDITION var )
 4262   
                         {
 4263  130 
                         Object root_1 = (Object)adaptor.nil();
 4264  130 
                         root_1 = (Object)adaptor.becomeRoot(
 4265   
                         (Object)adaptor.create(ORDER_CONDITION, "ORDER_CONDITION")
 4266   
                         , root_1);
 4267   
 
 4268  130 
                         adaptor.addChild(root_1, stream_var.nextTree());
 4269   
 
 4270  130 
                         adaptor.addChild(root_0, root_1);
 4271   
                         }
 4272   
 
 4273   
                     }
 4274   
 
 4275   
 
 4276  130 
                     retval.tree = root_0;
 4277   
 
 4278   
                     }
 4279   
                     break;
 4280   
 
 4281   
             }
 4282  182 
             retval.stop = input.LT(-1);
 4283   
 
 4284   
 
 4285  182 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4286  182 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4287   
 
 4288   
         }
 4289  0 
         catch (RecognitionException re) {
 4290  0 
             reportError(re);
 4291  0 
             recover(input,re);
 4292  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4293   
 
 4294   
         }
 4295   
 
 4296  0 
         finally {
 4297   
                 // do for sure before leaving
 4298  182 
         }
 4299  182 
         return retval;
 4300   
     }
 4301   
     // $ANTLR end "orderCondition"
 4302   
 
 4303   
 
 4304  58 
     public static class limitOffsetClauses_return extends ParserRuleReturnScope {
 4305   
         Object tree;
 4306  58 
         public Object getTree() { return tree; }
 4307   
     };
 4308   
 
 4309   
 
 4310   
     // $ANTLR start "limitOffsetClauses"
 4311   
     // com\\googlecode\\sparkleg\\Sparql.g:163:1: limitOffsetClauses : ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* );
 4312   
     public final SparqlParser.limitOffsetClauses_return limitOffsetClauses() throws RecognitionException {
 4313  58 
         SparqlParser.limitOffsetClauses_return retval = new SparqlParser.limitOffsetClauses_return();
 4314  58 
         retval.start = input.LT(1);
 4315   
 
 4316   
 
 4317  58 
         Object root_0 = null;
 4318   
 
 4319  58 
         SparqlParser.limitClause_return limitClause88 =null;
 4320   
 
 4321  58 
         SparqlParser.offsetClause_return offsetClause89 =null;
 4322   
 
 4323  58 
         SparqlParser.offsetClause_return offsetClause90 =null;
 4324   
 
 4325  58 
         SparqlParser.limitClause_return limitClause91 =null;
 4326   
 
 4327   
 
 4328  58 
         RewriteRuleSubtreeStream stream_offsetClause=new RewriteRuleSubtreeStream(adaptor,"rule offsetClause");
 4329  58 
         RewriteRuleSubtreeStream stream_limitClause=new RewriteRuleSubtreeStream(adaptor,"rule limitClause");
 4330   
         try {
 4331   
             // com\\googlecode\\sparkleg\\Sparql.g:164:5: ( limitClause ( offsetClause )? -> limitClause ( offsetClause )* | offsetClause ( limitClause )? -> offsetClause ( limitClause )* )
 4332  58 
             int alt34=2;
 4333  58 
             switch ( input.LA(1) ) {
 4334   
             case LIMIT:
 4335   
                 {
 4336  43 
                 alt34=1;
 4337   
                 }
 4338  43 
                 break;
 4339   
             case OFFSET:
 4340   
                 {
 4341  15 
                 alt34=2;
 4342   
                 }
 4343  15 
                 break;
 4344   
             default:
 4345  0 
                 NoViableAltException nvae =
 4346   
                     new NoViableAltException("", 34, 0, input);
 4347   
 
 4348  0 
                 throw nvae;
 4349   
 
 4350   
             }
 4351   
 
 4352  58 
             switch (alt34) {
 4353   
                 case 1 :
 4354   
                     // com\\googlecode\\sparkleg\\Sparql.g:164:7: limitClause ( offsetClause )?
 4355   
                     {
 4356  43 
                     pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1112);
 4357  43 
                     limitClause88=limitClause();
 4358   
 
 4359  43 
                     state._fsp--;
 4360   
 
 4361  43 
                     stream_limitClause.add(limitClause88.getTree());
 4362   
 
 4363   
                     // com\\googlecode\\sparkleg\\Sparql.g:164:19: ( offsetClause )?
 4364  43 
                     int alt32=2;
 4365  43 
                     switch ( input.LA(1) ) {
 4366   
                         case OFFSET:
 4367   
                             {
 4368  17 
                             alt32=1;
 4369   
                             }
 4370   
                             break;
 4371   
                     }
 4372   
 
 4373  43 
                     switch (alt32) {
 4374   
                         case 1 :
 4375   
                             // com\\googlecode\\sparkleg\\Sparql.g:164:19: offsetClause
 4376   
                             {
 4377  17 
                             pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1114);
 4378  17 
                             offsetClause89=offsetClause();
 4379   
 
 4380  17 
                             state._fsp--;
 4381   
 
 4382  17 
                             stream_offsetClause.add(offsetClause89.getTree());
 4383   
 
 4384   
                             }
 4385   
                             break;
 4386   
 
 4387   
                     }
 4388   
 
 4389   
 
 4390   
                     // AST REWRITE
 4391   
                     // elements: offsetClause, limitClause
 4392   
                     // token labels:
 4393   
                     // rule labels: retval
 4394   
                     // token list labels:
 4395   
                     // rule list labels:
 4396   
                     // wildcard labels:
 4397  43 
                     retval.tree = root_0;
 4398  43 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4399   
 
 4400  43 
                     root_0 = (Object)adaptor.nil();
 4401   
                     // 164:33: -> limitClause ( offsetClause )*
 4402   
                     {
 4403  43 
                         adaptor.addChild(root_0, stream_limitClause.nextTree());
 4404   
 
 4405   
                         // com\\googlecode\\sparkleg\\Sparql.g:164:48: ( offsetClause )*
 4406  60 
                         while ( stream_offsetClause.hasNext() ) {
 4407  17 
                             adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4408   
 
 4409   
                         }
 4410  43 
                         stream_offsetClause.reset();
 4411   
 
 4412   
                     }
 4413   
 
 4414   
 
 4415  43 
                     retval.tree = root_0;
 4416   
 
 4417   
                     }
 4418  43 
                     break;
 4419   
                 case 2 :
 4420   
                     // com\\googlecode\\sparkleg\\Sparql.g:165:7: offsetClause ( limitClause )?
 4421   
                     {
 4422  15 
                     pushFollow(FOLLOW_offsetClause_in_limitOffsetClauses1130);
 4423  15 
                     offsetClause90=offsetClause();
 4424   
 
 4425  15 
                     state._fsp--;
 4426   
 
 4427  15 
                     stream_offsetClause.add(offsetClause90.getTree());
 4428   
 
 4429   
                     // com\\googlecode\\sparkleg\\Sparql.g:165:20: ( limitClause )?
 4430  15 
                     int alt33=2;
 4431  15 
                     switch ( input.LA(1) ) {
 4432   
                         case LIMIT:
 4433   
                             {
 4434  5 
                             alt33=1;
 4435   
                             }
 4436   
                             break;
 4437   
                     }
 4438   
 
 4439  15 
                     switch (alt33) {
 4440   
                         case 1 :
 4441   
                             // com\\googlecode\\sparkleg\\Sparql.g:165:20: limitClause
 4442   
                             {
 4443  5 
                             pushFollow(FOLLOW_limitClause_in_limitOffsetClauses1132);
 4444  5 
                             limitClause91=limitClause();
 4445   
 
 4446  5 
                             state._fsp--;
 4447   
 
 4448  5 
                             stream_limitClause.add(limitClause91.getTree());
 4449   
 
 4450   
                             }
 4451   
                             break;
 4452   
 
 4453   
                     }
 4454   
 
 4455   
 
 4456   
                     // AST REWRITE
 4457   
                     // elements: offsetClause, limitClause
 4458   
                     // token labels:
 4459   
                     // rule labels: retval
 4460   
                     // token list labels:
 4461   
                     // rule list labels:
 4462   
                     // wildcard labels:
 4463  15 
                     retval.tree = root_0;
 4464  15 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4465   
 
 4466  15 
                     root_0 = (Object)adaptor.nil();
 4467   
                     // 165:33: -> offsetClause ( limitClause )*
 4468   
                     {
 4469  15 
                         adaptor.addChild(root_0, stream_offsetClause.nextTree());
 4470   
 
 4471   
                         // com\\googlecode\\sparkleg\\Sparql.g:165:49: ( limitClause )*
 4472  20 
                         while ( stream_limitClause.hasNext() ) {
 4473  5 
                             adaptor.addChild(root_0, stream_limitClause.nextTree());
 4474   
 
 4475   
                         }
 4476  15 
                         stream_limitClause.reset();
 4477   
 
 4478   
                     }
 4479   
 
 4480   
 
 4481  15 
                     retval.tree = root_0;
 4482   
 
 4483   
                     }
 4484   
                     break;
 4485   
 
 4486   
             }
 4487  58 
             retval.stop = input.LT(-1);
 4488   
 
 4489   
 
 4490  58 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4491  58 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4492   
 
 4493   
         }
 4494  0 
         catch (RecognitionException re) {
 4495  0 
             reportError(re);
 4496  0 
             recover(input,re);
 4497  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4498   
 
 4499   
         }
 4500   
 
 4501  0 
         finally {
 4502   
                 // do for sure before leaving
 4503  58 
         }
 4504  58 
         return retval;
 4505   
     }
 4506   
     // $ANTLR end "limitOffsetClauses"
 4507   
 
 4508   
 
 4509  48 
     public static class limitClause_return extends ParserRuleReturnScope {
 4510   
         Object tree;
 4511  48 
         public Object getTree() { return tree; }
 4512   
     };
 4513   
 
 4514   
 
 4515   
     // $ANTLR start "limitClause"
 4516   
     // com\\googlecode\\sparkleg\\Sparql.g:168:1: limitClause : LIMIT INTEGER -> ^( LIMIT INTEGER ) ;
 4517   
     public final SparqlParser.limitClause_return limitClause() throws RecognitionException {
 4518  48 
         SparqlParser.limitClause_return retval = new SparqlParser.limitClause_return();
 4519  48 
         retval.start = input.LT(1);
 4520   
 
 4521   
 
 4522  48 
         Object root_0 = null;
 4523   
 
 4524  48 
         Token LIMIT92=null;
 4525  48 
         Token INTEGER93=null;
 4526   
 
 4527  48 
         Object LIMIT92_tree=null;
 4528  48 
         Object INTEGER93_tree=null;
 4529  48 
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4530  48 
         RewriteRuleTokenStream stream_LIMIT=new RewriteRuleTokenStream(adaptor,"token LIMIT");
 4531   
 
 4532   
         try {
 4533   
             // com\\googlecode\\sparkleg\\Sparql.g:169:5: ( LIMIT INTEGER -> ^( LIMIT INTEGER ) )
 4534   
             // com\\googlecode\\sparkleg\\Sparql.g:169:7: LIMIT INTEGER
 4535   
             {
 4536  48 
             LIMIT92=(Token)match(input,LIMIT,FOLLOW_LIMIT_in_limitClause1157);
 4537  48 
             stream_LIMIT.add(LIMIT92);
 4538   
 
 4539   
 
 4540  48 
             INTEGER93=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_limitClause1159);
 4541  48 
             stream_INTEGER.add(INTEGER93);
 4542   
 
 4543   
 
 4544   
             // AST REWRITE
 4545   
             // elements: LIMIT, INTEGER
 4546   
             // token labels:
 4547   
             // rule labels: retval
 4548   
             // token list labels:
 4549   
             // rule list labels:
 4550   
             // wildcard labels:
 4551  48 
             retval.tree = root_0;
 4552  48 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4553   
 
 4554  48 
             root_0 = (Object)adaptor.nil();
 4555   
             // 169:21: -> ^( LIMIT INTEGER )
 4556   
             {
 4557   
                 // com\\googlecode\\sparkleg\\Sparql.g:169:24: ^( LIMIT INTEGER )
 4558   
                 {
 4559  48 
                 Object root_1 = (Object)adaptor.nil();
 4560  48 
                 root_1 = (Object)adaptor.becomeRoot(
 4561   
                 stream_LIMIT.nextNode()
 4562   
                 , root_1);
 4563   
 
 4564  48 
                 adaptor.addChild(root_1,
 4565   
                 stream_INTEGER.nextNode()
 4566   
                 );
 4567   
 
 4568  48 
                 adaptor.addChild(root_0, root_1);
 4569   
                 }
 4570   
 
 4571   
             }
 4572   
 
 4573   
 
 4574  48 
             retval.tree = root_0;
 4575   
 
 4576   
             }
 4577   
 
 4578  48 
             retval.stop = input.LT(-1);
 4579   
 
 4580   
 
 4581  48 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4582  48 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4583   
 
 4584   
         }
 4585  0 
         catch (RecognitionException re) {
 4586  0 
             reportError(re);
 4587  0 
             recover(input,re);
 4588  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4589   
 
 4590   
         }
 4591   
 
 4592  0 
         finally {
 4593   
                 // do for sure before leaving
 4594  48 
         }
 4595  48 
         return retval;
 4596   
     }
 4597   
     // $ANTLR end "limitClause"
 4598   
 
 4599   
 
 4600  32 
     public static class offsetClause_return extends ParserRuleReturnScope {
 4601   
         Object tree;
 4602  32 
         public Object getTree() { return tree; }
 4603   
     };
 4604   
 
 4605   
 
 4606   
     // $ANTLR start "offsetClause"
 4607   
     // com\\googlecode\\sparkleg\\Sparql.g:172:1: offsetClause : OFFSET INTEGER -> ^( OFFSET INTEGER ) ;
 4608   
     public final SparqlParser.offsetClause_return offsetClause() throws RecognitionException {
 4609  32 
         SparqlParser.offsetClause_return retval = new SparqlParser.offsetClause_return();
 4610  32 
         retval.start = input.LT(1);
 4611   
 
 4612   
 
 4613  32 
         Object root_0 = null;
 4614   
 
 4615  32 
         Token OFFSET94=null;
 4616  32 
         Token INTEGER95=null;
 4617   
 
 4618  32 
         Object OFFSET94_tree=null;
 4619  32 
         Object INTEGER95_tree=null;
 4620  32 
         RewriteRuleTokenStream stream_INTEGER=new RewriteRuleTokenStream(adaptor,"token INTEGER");
 4621  32 
         RewriteRuleTokenStream stream_OFFSET=new RewriteRuleTokenStream(adaptor,"token OFFSET");
 4622   
 
 4623   
         try {
 4624   
             // com\\googlecode\\sparkleg\\Sparql.g:173:5: ( OFFSET INTEGER -> ^( OFFSET INTEGER ) )
 4625   
             // com\\googlecode\\sparkleg\\Sparql.g:173:7: OFFSET INTEGER
 4626   
             {
 4627  32 
             OFFSET94=(Token)match(input,OFFSET,FOLLOW_OFFSET_in_offsetClause1184);
 4628  32 
             stream_OFFSET.add(OFFSET94);
 4629   
 
 4630   
 
 4631  32 
             INTEGER95=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_offsetClause1186);
 4632  32 
             stream_INTEGER.add(INTEGER95);
 4633   
 
 4634   
 
 4635   
             // AST REWRITE
 4636   
             // elements: OFFSET, INTEGER
 4637   
             // token labels:
 4638   
             // rule labels: retval
 4639   
             // token list labels:
 4640   
             // rule list labels:
 4641   
             // wildcard labels:
 4642  32 
             retval.tree = root_0;
 4643  32 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4644   
 
 4645  32 
             root_0 = (Object)adaptor.nil();
 4646   
             // 173:22: -> ^( OFFSET INTEGER )
 4647   
             {
 4648   
                 // com\\googlecode\\sparkleg\\Sparql.g:173:25: ^( OFFSET INTEGER )
 4649   
                 {
 4650  32 
                 Object root_1 = (Object)adaptor.nil();
 4651  32 
                 root_1 = (Object)adaptor.becomeRoot(
 4652   
                 stream_OFFSET.nextNode()
 4653   
                 , root_1);
 4654   
 
 4655  32 
                 adaptor.addChild(root_1,
 4656   
                 stream_INTEGER.nextNode()
 4657   
                 );
 4658   
 
 4659  32 
                 adaptor.addChild(root_0, root_1);
 4660   
                 }
 4661   
 
 4662   
             }
 4663   
 
 4664   
 
 4665  32 
             retval.tree = root_0;
 4666   
 
 4667   
             }
 4668   
 
 4669  32 
             retval.stop = input.LT(-1);
 4670   
 
 4671   
 
 4672  32 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4673  32 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4674   
 
 4675   
         }
 4676  0 
         catch (RecognitionException re) {
 4677  0 
             reportError(re);
 4678  0 
             recover(input,re);
 4679  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4680   
 
 4681   
         }
 4682   
 
 4683  0 
         finally {
 4684   
                 // do for sure before leaving
 4685  32 
         }
 4686  32 
         return retval;
 4687   
     }
 4688   
     // $ANTLR end "offsetClause"
 4689   
 
 4690   
 
 4691  1774 
     public static class bindingsClause_return extends ParserRuleReturnScope {
 4692   
         Object tree;
 4693  1774 
         public Object getTree() { return tree; }
 4694   
     };
 4695   
 
 4696   
 
 4697   
     // $ANTLR start "bindingsClause"
 4698   
     // com\\googlecode\\sparkleg\\Sparql.g:176:1: bindingsClause : ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? ;
 4699   
     public final SparqlParser.bindingsClause_return bindingsClause() throws RecognitionException {
 4700  1774 
         SparqlParser.bindingsClause_return retval = new SparqlParser.bindingsClause_return();
 4701  1774 
         retval.start = input.LT(1);
 4702   
 
 4703   
 
 4704  1774 
         Object root_0 = null;
 4705   
 
 4706  1774 
         Token BINDINGS96=null;
 4707  1774 
         Token OPEN_CURLY_BRACE98=null;
 4708  1774 
         Token CLOSE_CURLY_BRACE100=null;
 4709  1774 
         SparqlParser.var_return var97 =null;
 4710   
 
 4711  1774 
         SparqlParser.bindingValueList_return bindingValueList99 =null;
 4712   
 
 4713   
 
 4714  1774 
         Object BINDINGS96_tree=null;
 4715  1774 
         Object OPEN_CURLY_BRACE98_tree=null;
 4716  1774 
         Object CLOSE_CURLY_BRACE100_tree=null;
 4717  1774 
         RewriteRuleTokenStream stream_BINDINGS=new RewriteRuleTokenStream(adaptor,"token BINDINGS");
 4718  1774 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 4719  1774 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 4720  1774 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 4721  1774 
         RewriteRuleSubtreeStream stream_bindingValueList=new RewriteRuleSubtreeStream(adaptor,"rule bindingValueList");
 4722   
         try {
 4723   
             // com\\googlecode\\sparkleg\\Sparql.g:177:5: ( ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )? -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )? )
 4724   
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4725   
             {
 4726   
             // com\\googlecode\\sparkleg\\Sparql.g:177:7: ( BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE )?
 4727  1774 
             int alt37=2;
 4728  1774 
             switch ( input.LA(1) ) {
 4729   
                 case BINDINGS:
 4730   
                     {
 4731  26 
                     alt37=1;
 4732   
                     }
 4733   
                     break;
 4734   
             }
 4735   
 
 4736  1774 
             switch (alt37) {
 4737   
                 case 1 :
 4738   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:8: BINDINGS ( var )* OPEN_CURLY_BRACE ( bindingValueList )* CLOSE_CURLY_BRACE
 4739   
                     {
 4740  26 
                     BINDINGS96=(Token)match(input,BINDINGS,FOLLOW_BINDINGS_in_bindingsClause1212);
 4741  26 
                     stream_BINDINGS.add(BINDINGS96);
 4742   
 
 4743   
 
 4744   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:17: ( var )*
 4745   
                     loop35:
 4746   
                     do {
 4747  64 
                         int alt35=2;
 4748  64 
                         switch ( input.LA(1) ) {
 4749   
                         case VAR1:
 4750   
                         case VAR2:
 4751   
                             {
 4752  38 
                             alt35=1;
 4753   
                             }
 4754   
                             break;
 4755   
 
 4756   
                         }
 4757   
 
 4758  64 
                         switch (alt35) {
 4759   
                             case 1 :
 4760   
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:17: var
 4761   
                                 {
 4762  38 
                                 pushFollow(FOLLOW_var_in_bindingsClause1214);
 4763  38 
                                 var97=var();
 4764   
 
 4765  38 
                                 state._fsp--;
 4766   
 
 4767  38 
                                 stream_var.add(var97.getTree());
 4768   
 
 4769   
                                 }
 4770  38 
                                 break;
 4771   
 
 4772   
                             default :
 4773  26 
                                 break loop35;
 4774   
                         }
 4775  38 
                     } while (true);
 4776   
 
 4777   
 
 4778  26 
                     OPEN_CURLY_BRACE98=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1217);
 4779  26 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE98);
 4780   
 
 4781   
 
 4782   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:39: ( bindingValueList )*
 4783   
                     loop36:
 4784   
                     do {
 4785  60 
                         int alt36=2;
 4786  60 
                         switch ( input.LA(1) ) {
 4787   
                         case OPEN_BRACE:
 4788   
                             {
 4789  34 
                             alt36=1;
 4790   
                             }
 4791   
                             break;
 4792   
 
 4793   
                         }
 4794   
 
 4795  60 
                         switch (alt36) {
 4796   
                             case 1 :
 4797   
                                 // com\\googlecode\\sparkleg\\Sparql.g:177:39: bindingValueList
 4798   
                                 {
 4799  34 
                                 pushFollow(FOLLOW_bindingValueList_in_bindingsClause1219);
 4800  34 
                                 bindingValueList99=bindingValueList();
 4801   
 
 4802  34 
                                 state._fsp--;
 4803   
 
 4804  34 
                                 stream_bindingValueList.add(bindingValueList99.getTree());
 4805   
 
 4806   
                                 }
 4807  34 
                                 break;
 4808   
 
 4809   
                             default :
 4810  26 
                                 break loop36;
 4811   
                         }
 4812  34 
                     } while (true);
 4813   
 
 4814   
 
 4815  26 
                     CLOSE_CURLY_BRACE100=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1222);
 4816  26 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE100);
 4817   
 
 4818   
 
 4819   
                     }
 4820   
                     break;
 4821   
 
 4822   
             }
 4823   
 
 4824   
 
 4825   
             // AST REWRITE
 4826   
             // elements: var, BINDINGS, bindingValueList
 4827   
             // token labels:
 4828   
             // rule labels: retval
 4829   
             // token list labels:
 4830   
             // rule list labels:
 4831   
             // wildcard labels:
 4832  1774 
             retval.tree = root_0;
 4833  1774 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4834   
 
 4835  1774 
             root_0 = (Object)adaptor.nil();
 4836   
             // 177:77: -> ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4837   
             {
 4838   
                 // com\\googlecode\\sparkleg\\Sparql.g:177:80: ( ^( BINDINGS ( var )* ( bindingValueList )* ) )?
 4839  1774 
                 if ( stream_var.hasNext()||stream_BINDINGS.hasNext()||stream_bindingValueList.hasNext() ) {
 4840   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:80: ^( BINDINGS ( var )* ( bindingValueList )* )
 4841   
                     {
 4842  26 
                     Object root_1 = (Object)adaptor.nil();
 4843  26 
                     root_1 = (Object)adaptor.becomeRoot(
 4844   
                     stream_BINDINGS.nextNode()
 4845   
                     , root_1);
 4846   
 
 4847   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:91: ( var )*
 4848  64 
                     while ( stream_var.hasNext() ) {
 4849  38 
                         adaptor.addChild(root_1, stream_var.nextTree());
 4850   
 
 4851   
                     }
 4852  26 
                     stream_var.reset();
 4853   
 
 4854   
                     // com\\googlecode\\sparkleg\\Sparql.g:177:96: ( bindingValueList )*
 4855  60 
                     while ( stream_bindingValueList.hasNext() ) {
 4856  34 
                         adaptor.addChild(root_1, stream_bindingValueList.nextTree());
 4857   
 
 4858   
                     }
 4859  26 
                     stream_bindingValueList.reset();
 4860   
 
 4861  26 
                     adaptor.addChild(root_0, root_1);
 4862   
                     }
 4863   
 
 4864   
                 }
 4865  1774 
                 stream_var.reset();
 4866  1774 
                 stream_BINDINGS.reset();
 4867  1774 
                 stream_bindingValueList.reset();
 4868   
 
 4869   
             }
 4870   
 
 4871   
 
 4872  1774 
             retval.tree = root_0;
 4873   
 
 4874   
             }
 4875   
 
 4876  1774 
             retval.stop = input.LT(-1);
 4877   
 
 4878   
 
 4879  1774 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 4880  1774 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 4881   
 
 4882   
         }
 4883  0 
         catch (RecognitionException re) {
 4884  0 
             reportError(re);
 4885  0 
             recover(input,re);
 4886  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 4887   
 
 4888   
         }
 4889   
 
 4890  0 
         finally {
 4891   
                 // do for sure before leaving
 4892  1774 
         }
 4893  1774 
         return retval;
 4894   
     }
 4895   
     // $ANTLR end "bindingsClause"
 4896   
 
 4897   
 
 4898  34 
     public static class bindingValueList_return extends ParserRuleReturnScope {
 4899   
         Object tree;
 4900  34 
         public Object getTree() { return tree; }
 4901   
     };
 4902   
 
 4903   
 
 4904   
     // $ANTLR start "bindingValueList"
 4905   
     // com\\googlecode\\sparkleg\\Sparql.g:180:1: bindingValueList : OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) ;
 4906   
     public final SparqlParser.bindingValueList_return bindingValueList() throws RecognitionException {
 4907  34 
         SparqlParser.bindingValueList_return retval = new SparqlParser.bindingValueList_return();
 4908  34 
         retval.start = input.LT(1);
 4909   
 
 4910   
 
 4911  34 
         Object root_0 = null;
 4912   
 
 4913  34 
         Token OPEN_BRACE101=null;
 4914  34 
         Token CLOSE_BRACE103=null;
 4915  34 
         SparqlParser.bindingValue_return bindingValue102 =null;
 4916   
 
 4917   
 
 4918  34 
         Object OPEN_BRACE101_tree=null;
 4919  34 
         Object CLOSE_BRACE103_tree=null;
 4920  34 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 4921  34 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 4922  34 
         RewriteRuleSubtreeStream stream_bindingValue=new RewriteRuleSubtreeStream(adaptor,"rule bindingValue");
 4923   
         try {
 4924   
             // com\\googlecode\\sparkleg\\Sparql.g:181:5: ( OPEN_BRACE ( bindingValue )* CLOSE_BRACE -> ^( BINDING_VALUE ( bindingValue )* ) )
 4925   
             // com\\googlecode\\sparkleg\\Sparql.g:181:7: OPEN_BRACE ( bindingValue )* CLOSE_BRACE
 4926   
             {
 4927  34 
             OPEN_BRACE101=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bindingValueList1258);
 4928  34 
             stream_OPEN_BRACE.add(OPEN_BRACE101);
 4929   
 
 4930   
 
 4931   
             // com\\googlecode\\sparkleg\\Sparql.g:181:18: ( bindingValue )*
 4932   
             loop38:
 4933   
             do {
 4934  88 
                 int alt38=2;
 4935  88 
                 switch ( input.LA(1) ) {
 4936   
                 case DECIMAL:
 4937   
                 case DECIMAL_NEGATIVE:
 4938   
                 case DECIMAL_POSITIVE:
 4939   
                 case DOUBLE:
 4940   
                 case DOUBLE_NEGATIVE:
 4941   
                 case DOUBLE_POSITIVE:
 4942   
                 case FALSE:
 4943   
                 case INTEGER:
 4944   
                 case INTEGER_NEGATIVE:
 4945   
                 case INTEGER_POSITIVE:
 4946   
                 case IRI_REF:
 4947   
                 case PNAME_LN:
 4948   
                 case PNAME_NS:
 4949   
                 case STRING_LITERAL1:
 4950   
                 case STRING_LITERAL2:
 4951   
                 case STRING_LITERAL_LONG1:
 4952   
                 case STRING_LITERAL_LONG2:
 4953   
                 case TRUE:
 4954   
                 case UNDEF:
 4955   
                     {
 4956  54 
                     alt38=1;
 4957   
                     }
 4958   
                     break;
 4959   
 
 4960   
                 }
 4961   
 
 4962  88 
                 switch (alt38) {
 4963   
                     case 1 :
 4964   
                         // com\\googlecode\\sparkleg\\Sparql.g:181:18: bindingValue
 4965   
                         {
 4966  54 
                         pushFollow(FOLLOW_bindingValue_in_bindingValueList1260);
 4967  54 
                         bindingValue102=bindingValue();
 4968   
 
 4969  54 
                         state._fsp--;
 4970   
 
 4971  54 
                         stream_bindingValue.add(bindingValue102.getTree());
 4972   
 
 4973   
                         }
 4974  54 
                         break;
 4975   
 
 4976   
                     default :
 4977  34 
                         break loop38;
 4978   
                 }
 4979  54 
             } while (true);
 4980   
 
 4981   
 
 4982  34 
             CLOSE_BRACE103=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bindingValueList1263);
 4983  34 
             stream_CLOSE_BRACE.add(CLOSE_BRACE103);
 4984   
 
 4985   
 
 4986   
             // AST REWRITE
 4987   
             // elements: bindingValue
 4988   
             // token labels:
 4989   
             // rule labels: retval
 4990   
             // token list labels:
 4991   
             // rule list labels:
 4992   
             // wildcard labels:
 4993  34 
             retval.tree = root_0;
 4994  34 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 4995   
 
 4996  34 
             root_0 = (Object)adaptor.nil();
 4997   
             // 181:44: -> ^( BINDING_VALUE ( bindingValue )* )
 4998   
             {
 4999   
                 // com\\googlecode\\sparkleg\\Sparql.g:181:47: ^( BINDING_VALUE ( bindingValue )* )
 5000   
                 {
 5001  34 
                 Object root_1 = (Object)adaptor.nil();
 5002  34 
                 root_1 = (Object)adaptor.becomeRoot(
 5003   
                 (Object)adaptor.create(BINDING_VALUE, "BINDING_VALUE")
 5004   
                 , root_1);
 5005   
 
 5006   
                 // com\\googlecode\\sparkleg\\Sparql.g:181:63: ( bindingValue )*
 5007  88 
                 while ( stream_bindingValue.hasNext() ) {
 5008  54 
                     adaptor.addChild(root_1, stream_bindingValue.nextTree());
 5009   
 
 5010   
                 }
 5011  34 
                 stream_bindingValue.reset();
 5012   
 
 5013  34 
                 adaptor.addChild(root_0, root_1);
 5014   
                 }
 5015   
 
 5016   
             }
 5017   
 
 5018   
 
 5019  34 
             retval.tree = root_0;
 5020   
 
 5021   
             }
 5022   
 
 5023  34 
             retval.stop = input.LT(-1);
 5024   
 
 5025   
 
 5026  34 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5027  34 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5028   
 
 5029   
         }
 5030  0 
         catch (RecognitionException re) {
 5031  0 
             reportError(re);
 5032  0 
             recover(input,re);
 5033  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5034   
 
 5035   
         }
 5036   
 
 5037  0 
         finally {
 5038   
                 // do for sure before leaving
 5039  34 
         }
 5040  34 
         return retval;
 5041   
     }
 5042   
     // $ANTLR end "bindingValueList"
 5043   
 
 5044   
 
 5045  54 
     public static class bindingValue_return extends ParserRuleReturnScope {
 5046   
         Object tree;
 5047  54 
         public Object getTree() { return tree; }
 5048   
     };
 5049   
 
 5050   
 
 5051   
     // $ANTLR start "bindingValue"
 5052   
     // com\\googlecode\\sparkleg\\Sparql.g:184:1: bindingValue : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF );
 5053   
     public final SparqlParser.bindingValue_return bindingValue() throws RecognitionException {
 5054  54 
         SparqlParser.bindingValue_return retval = new SparqlParser.bindingValue_return();
 5055  54 
         retval.start = input.LT(1);
 5056   
 
 5057   
 
 5058  54 
         Object root_0 = null;
 5059   
 
 5060  54 
         Token UNDEF108=null;
 5061  54 
         SparqlParser.iriRef_return iriRef104 =null;
 5062   
 
 5063  54 
         SparqlParser.rdfLiteral_return rdfLiteral105 =null;
 5064   
 
 5065  54 
         SparqlParser.numericLiteral_return numericLiteral106 =null;
 5066   
 
 5067  54 
         SparqlParser.booleanLiteral_return booleanLiteral107 =null;
 5068   
 
 5069   
 
 5070  54 
         Object UNDEF108_tree=null;
 5071   
 
 5072   
         try {
 5073   
             // com\\googlecode\\sparkleg\\Sparql.g:185:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | UNDEF )
 5074  54 
             int alt39=5;
 5075  54 
             switch ( input.LA(1) ) {
 5076   
             case IRI_REF:
 5077   
             case PNAME_LN:
 5078   
             case PNAME_NS:
 5079   
                 {
 5080  22 
                 alt39=1;
 5081   
                 }
 5082  22 
                 break;
 5083   
             case STRING_LITERAL1:
 5084   
             case STRING_LITERAL2:
 5085   
             case STRING_LITERAL_LONG1:
 5086   
             case STRING_LITERAL_LONG2:
 5087   
                 {
 5088  14 
                 alt39=2;
 5089   
                 }
 5090  14 
                 break;
 5091   
             case DECIMAL:
 5092   
             case DECIMAL_NEGATIVE:
 5093   
             case DECIMAL_POSITIVE:
 5094   
             case DOUBLE:
 5095   
             case DOUBLE_NEGATIVE:
 5096   
             case DOUBLE_POSITIVE:
 5097   
             case INTEGER:
 5098   
             case INTEGER_NEGATIVE:
 5099   
             case INTEGER_POSITIVE:
 5100   
                 {
 5101  0 
                 alt39=3;
 5102   
                 }
 5103  0 
                 break;
 5104   
             case FALSE:
 5105   
             case TRUE:
 5106   
                 {
 5107  0 
                 alt39=4;
 5108   
                 }
 5109  0 
                 break;
 5110   
             case UNDEF:
 5111   
                 {
 5112  18 
                 alt39=5;
 5113   
                 }
 5114  18 
                 break;
 5115   
             default:
 5116  0 
                 NoViableAltException nvae =
 5117   
                     new NoViableAltException("", 39, 0, input);
 5118   
 
 5119  0 
                 throw nvae;
 5120   
 
 5121   
             }
 5122   
 
 5123  54 
             switch (alt39) {
 5124   
                 case 1 :
 5125   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:7: iriRef
 5126   
                     {
 5127  22 
                     root_0 = (Object)adaptor.nil();
 5128   
 
 5129   
 
 5130  22 
                     pushFollow(FOLLOW_iriRef_in_bindingValue1294);
 5131  22 
                     iriRef104=iriRef();
 5132   
 
 5133  22 
                     state._fsp--;
 5134   
 
 5135  22 
                     adaptor.addChild(root_0, iriRef104.getTree());
 5136   
 
 5137   
                     }
 5138  22 
                     break;
 5139   
                 case 2 :
 5140   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:16: rdfLiteral
 5141   
                     {
 5142  14 
                     root_0 = (Object)adaptor.nil();
 5143   
 
 5144   
 
 5145  14 
                     pushFollow(FOLLOW_rdfLiteral_in_bindingValue1298);
 5146  14 
                     rdfLiteral105=rdfLiteral();
 5147   
 
 5148  14 
                     state._fsp--;
 5149   
 
 5150  14 
                     adaptor.addChild(root_0, rdfLiteral105.getTree());
 5151   
 
 5152   
                     }
 5153  14 
                     break;
 5154   
                 case 3 :
 5155   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:29: numericLiteral
 5156   
                     {
 5157  0 
                     root_0 = (Object)adaptor.nil();
 5158   
 
 5159   
 
 5160  0 
                     pushFollow(FOLLOW_numericLiteral_in_bindingValue1302);
 5161  0 
                     numericLiteral106=numericLiteral();
 5162   
 
 5163  0 
                     state._fsp--;
 5164   
 
 5165  0 
                     adaptor.addChild(root_0, numericLiteral106.getTree());
 5166   
 
 5167   
                     }
 5168  0 
                     break;
 5169   
                 case 4 :
 5170   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:46: booleanLiteral
 5171   
                     {
 5172  0 
                     root_0 = (Object)adaptor.nil();
 5173   
 
 5174   
 
 5175  0 
                     pushFollow(FOLLOW_booleanLiteral_in_bindingValue1306);
 5176  0 
                     booleanLiteral107=booleanLiteral();
 5177   
 
 5178  0 
                     state._fsp--;
 5179   
 
 5180  0 
                     adaptor.addChild(root_0, booleanLiteral107.getTree());
 5181   
 
 5182   
                     }
 5183  0 
                     break;
 5184   
                 case 5 :
 5185   
                     // com\\googlecode\\sparkleg\\Sparql.g:185:63: UNDEF
 5186   
                     {
 5187  18 
                     root_0 = (Object)adaptor.nil();
 5188   
 
 5189   
 
 5190  18 
                     UNDEF108=(Token)match(input,UNDEF,FOLLOW_UNDEF_in_bindingValue1310);
 5191  18 
                     UNDEF108_tree =
 5192   
                     (Object)adaptor.create(UNDEF108)
 5193   
                     ;
 5194  18 
                     adaptor.addChild(root_0, UNDEF108_tree);
 5195   
 
 5196   
 
 5197   
                     }
 5198   
                     break;
 5199   
 
 5200   
             }
 5201  54 
             retval.stop = input.LT(-1);
 5202   
 
 5203   
 
 5204  54 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5205  54 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5206   
 
 5207   
         }
 5208  0 
         catch (RecognitionException re) {
 5209  0 
             reportError(re);
 5210  0 
             recover(input,re);
 5211  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5212   
 
 5213   
         }
 5214   
 
 5215  0 
         finally {
 5216   
                 // do for sure before leaving
 5217  54 
         }
 5218  54 
         return retval;
 5219   
     }
 5220   
     // $ANTLR end "bindingValue"
 5221   
 
 5222   
 
 5223  128 
     public static class update_return extends ParserRuleReturnScope {
 5224   
         Object tree;
 5225  128 
         public Object getTree() { return tree; }
 5226   
     };
 5227   
 
 5228   
 
 5229   
     // $ANTLR start "update"
 5230   
     // com\\googlecode\\sparkleg\\Sparql.g:188:1: update : prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* ;
 5231   
     public final SparqlParser.update_return update() throws RecognitionException {
 5232  128 
         SparqlParser.update_return retval = new SparqlParser.update_return();
 5233  128 
         retval.start = input.LT(1);
 5234   
 
 5235   
 
 5236  128 
         Object root_0 = null;
 5237   
 
 5238  128 
         SparqlParser.prologue_return prologue109 =null;
 5239   
 
 5240  128 
         SparqlParser.load_return load110 =null;
 5241   
 
 5242  128 
         SparqlParser.clear_return clear111 =null;
 5243   
 
 5244  128 
         SparqlParser.drop_return drop112 =null;
 5245   
 
 5246  128 
         SparqlParser.add_return add113 =null;
 5247   
 
 5248  128 
         SparqlParser.move_return move114 =null;
 5249   
 
 5250  128 
         SparqlParser.copy_return copy115 =null;
 5251   
 
 5252  128 
         SparqlParser.create_return create116 =null;
 5253   
 
 5254  128 
         SparqlParser.insert_return insert117 =null;
 5255   
 
 5256  128 
         SparqlParser.delete_return delete118 =null;
 5257   
 
 5258  128 
         SparqlParser.modify_return modify119 =null;
 5259   
 
 5260   
 
 5261  128 
         RewriteRuleSubtreeStream stream_clear=new RewriteRuleSubtreeStream(adaptor,"rule clear");
 5262  128 
         RewriteRuleSubtreeStream stream_prologue=new RewriteRuleSubtreeStream(adaptor,"rule prologue");
 5263  128 
         RewriteRuleSubtreeStream stream_drop=new RewriteRuleSubtreeStream(adaptor,"rule drop");
 5264  128 
         RewriteRuleSubtreeStream stream_delete=new RewriteRuleSubtreeStream(adaptor,"rule delete");
 5265  128 
         RewriteRuleSubtreeStream stream_modify=new RewriteRuleSubtreeStream(adaptor,"rule modify");
 5266  128 
         RewriteRuleSubtreeStream stream_load=new RewriteRuleSubtreeStream(adaptor,"rule load");
 5267  128 
         RewriteRuleSubtreeStream stream_add=new RewriteRuleSubtreeStream(adaptor,"rule add");
 5268  128 
         RewriteRuleSubtreeStream stream_insert=new RewriteRuleSubtreeStream(adaptor,"rule insert");
 5269  128 
         RewriteRuleSubtreeStream stream_create=new RewriteRuleSubtreeStream(adaptor,"rule create");
 5270  128 
         RewriteRuleSubtreeStream stream_move=new RewriteRuleSubtreeStream(adaptor,"rule move");
 5271  128 
         RewriteRuleSubtreeStream stream_copy=new RewriteRuleSubtreeStream(adaptor,"rule copy");
 5272   
         try {
 5273   
             // com\\googlecode\\sparkleg\\Sparql.g:189:5: ( prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify ) -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )* )
 5274   
             // com\\googlecode\\sparkleg\\Sparql.g:189:7: prologue ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5275   
             {
 5276  128 
             pushFollow(FOLLOW_prologue_in_update1331);
 5277  128 
             prologue109=prologue();
 5278   
 
 5279  128 
             state._fsp--;
 5280   
 
 5281  128 
             stream_prologue.add(prologue109.getTree());
 5282   
 
 5283   
             // com\\googlecode\\sparkleg\\Sparql.g:189:16: ( load | clear | drop | add | move | copy | create | insert | delete | modify )
 5284  128 
             int alt40=10;
 5285  128 
             switch ( input.LA(1) ) {
 5286   
             case LOAD:
 5287   
                 {
 5288  0 
                 alt40=1;
 5289   
                 }
 5290  0 
                 break;
 5291   
             case CLEAR:
 5292   
                 {
 5293  8 
                 alt40=2;
 5294   
                 }
 5295  8 
                 break;
 5296   
             case DROP:
 5297   
                 {
 5298  8 
                 alt40=3;
 5299   
                 }
 5300  8 
                 break;
 5301   
             case ADD:
 5302   
                 {
 5303  0 
                 alt40=4;
 5304   
                 }
 5305  0 
                 break;
 5306   
             case MOVE:
 5307   
                 {
 5308  0 
                 alt40=5;
 5309   
                 }
 5310  0 
                 break;
 5311   
             case COPY:
 5312   
                 {
 5313  0 
                 alt40=6;
 5314   
                 }
 5315  0 
                 break;
 5316   
             case CREATE:
 5317   
                 {
 5318  0 
                 alt40=7;
 5319   
                 }
 5320  0 
                 break;
 5321   
             case INSERT:
 5322   
                 {
 5323  20 
                 switch ( input.LA(2) ) {
 5324   
                 case DATA:
 5325   
                     {
 5326  8 
                     alt40=8;
 5327   
                     }
 5328  8 
                     break;
 5329   
                 case OPEN_CURLY_BRACE:
 5330   
                     {
 5331  12 
                     alt40=10;
 5332   
                     }
 5333  12 
                     break;
 5334   
                 default:
 5335  0 
                     NoViableAltException nvae =
 5336   
                         new NoViableAltException("", 40, 8, input);
 5337   
 
 5338  0 
                     throw nvae;
 5339   
 
 5340   
                 }
 5341   
 
 5342   
                 }
 5343  20 
                 break;
 5344   
             case DELETE:
 5345   
                 {
 5346  78 
                 switch ( input.LA(2) ) {
 5347   
                 case DATA:
 5348   
                 case WHERE:
 5349   
                     {
 5350  24 
                     alt40=9;
 5351   
                     }
 5352  24 
                     break;
 5353   
                 case OPEN_CURLY_BRACE:
 5354   
                     {
 5355  54 
                     alt40=10;
 5356   
                     }
 5357  54 
                     break;
 5358   
                 default:
 5359  0 
                     NoViableAltException nvae =
 5360   
                         new NoViableAltException("", 40, 9, input);
 5361   
 
 5362  0 
                     throw nvae;
 5363   
 
 5364   
                 }
 5365   
 
 5366   
                 }
 5367  78 
                 break;
 5368   
             case WITH:
 5369   
                 {
 5370  14 
                 alt40=10;
 5371   
                 }
 5372  14 
                 break;
 5373   
             default:
 5374  0 
                 NoViableAltException nvae =
 5375   
                     new NoViableAltException("", 40, 0, input);
 5376   
 
 5377  0 
                 throw nvae;
 5378   
 
 5379   
             }
 5380   
 
 5381  128 
             switch (alt40) {
 5382   
                 case 1 :
 5383   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:17: load
 5384   
                     {
 5385  0 
                     pushFollow(FOLLOW_load_in_update1334);
 5386  0 
                     load110=load();
 5387   
 
 5388  0 
                     state._fsp--;
 5389   
 
 5390  0 
                     stream_load.add(load110.getTree());
 5391   
 
 5392   
                     }
 5393  0 
                     break;
 5394   
                 case 2 :
 5395   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:24: clear
 5396   
                     {
 5397  8 
                     pushFollow(FOLLOW_clear_in_update1338);
 5398  8 
                     clear111=clear();
 5399   
 
 5400  8 
                     state._fsp--;
 5401   
 
 5402  8 
                     stream_clear.add(clear111.getTree());
 5403   
 
 5404   
                     }
 5405  8 
                     break;
 5406   
                 case 3 :
 5407   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:32: drop
 5408   
                     {
 5409  8 
                     pushFollow(FOLLOW_drop_in_update1342);
 5410  8 
                     drop112=drop();
 5411   
 
 5412  8 
                     state._fsp--;
 5413   
 
 5414  8 
                     stream_drop.add(drop112.getTree());
 5415   
 
 5416   
                     }
 5417  8 
                     break;
 5418   
                 case 4 :
 5419   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:39: add
 5420   
                     {
 5421  0 
                     pushFollow(FOLLOW_add_in_update1346);
 5422  0 
                     add113=add();
 5423   
 
 5424  0 
                     state._fsp--;
 5425   
 
 5426  0 
                     stream_add.add(add113.getTree());
 5427   
 
 5428   
                     }
 5429  0 
                     break;
 5430   
                 case 5 :
 5431   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:45: move
 5432   
                     {
 5433  0 
                     pushFollow(FOLLOW_move_in_update1350);
 5434  0 
                     move114=move();
 5435   
 
 5436  0 
                     state._fsp--;
 5437   
 
 5438  0 
                     stream_move.add(move114.getTree());
 5439   
 
 5440   
                     }
 5441  0 
                     break;
 5442   
                 case 6 :
 5443   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:52: copy
 5444   
                     {
 5445  0 
                     pushFollow(FOLLOW_copy_in_update1354);
 5446  0 
                     copy115=copy();
 5447   
 
 5448  0 
                     state._fsp--;
 5449   
 
 5450  0 
                     stream_copy.add(copy115.getTree());
 5451   
 
 5452   
                     }
 5453  0 
                     break;
 5454   
                 case 7 :
 5455   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:59: create
 5456   
                     {
 5457  0 
                     pushFollow(FOLLOW_create_in_update1358);
 5458  0 
                     create116=create();
 5459   
 
 5460  0 
                     state._fsp--;
 5461   
 
 5462  0 
                     stream_create.add(create116.getTree());
 5463   
 
 5464   
                     }
 5465  0 
                     break;
 5466   
                 case 8 :
 5467   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:68: insert
 5468   
                     {
 5469  8 
                     pushFollow(FOLLOW_insert_in_update1362);
 5470  8 
                     insert117=insert();
 5471   
 
 5472  8 
                     state._fsp--;
 5473   
 
 5474  8 
                     stream_insert.add(insert117.getTree());
 5475   
 
 5476   
                     }
 5477  8 
                     break;
 5478   
                 case 9 :
 5479   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:77: delete
 5480   
                     {
 5481  24 
                     pushFollow(FOLLOW_delete_in_update1366);
 5482  24 
                     delete118=delete();
 5483   
 
 5484  24 
                     state._fsp--;
 5485   
 
 5486  24 
                     stream_delete.add(delete118.getTree());
 5487   
 
 5488   
                     }
 5489  24 
                     break;
 5490   
                 case 10 :
 5491   
                     // com\\googlecode\\sparkleg\\Sparql.g:189:86: modify
 5492   
                     {
 5493  80 
                     pushFollow(FOLLOW_modify_in_update1370);
 5494  80 
                     modify119=modify();
 5495   
 
 5496  80 
                     state._fsp--;
 5497   
 
 5498  80 
                     stream_modify.add(modify119.getTree());
 5499   
 
 5500   
                     }
 5501   
                     break;
 5502   
 
 5503   
             }
 5504   
 
 5505   
 
 5506   
             // AST REWRITE
 5507   
             // elements: clear, modify, move, drop, prologue, delete, load, copy, create, add, insert
 5508   
             // token labels:
 5509   
             // rule labels: retval
 5510   
             // token list labels:
 5511   
             // rule list labels:
 5512   
             // wildcard labels:
 5513  128 
             retval.tree = root_0;
 5514  128 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5515   
 
 5516  128 
             root_0 = (Object)adaptor.nil();
 5517   
             // 189:94: -> prologue ( load )* ( clear )* ( drop )* ( add )* ( move )* ( copy )* ( create )* ( insert )* ( delete )* ( modify )*
 5518   
             {
 5519  128 
                 adaptor.addChild(root_0, stream_prologue.nextTree());
 5520   
 
 5521   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:106: ( load )*
 5522  128 
                 while ( stream_load.hasNext() ) {
 5523  0 
                     adaptor.addChild(root_0, stream_load.nextTree());
 5524   
 
 5525   
                 }
 5526  128 
                 stream_load.reset();
 5527   
 
 5528   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:112: ( clear )*
 5529  136 
                 while ( stream_clear.hasNext() ) {
 5530  8 
                     adaptor.addChild(root_0, stream_clear.nextTree());
 5531   
 
 5532   
                 }
 5533  128 
                 stream_clear.reset();
 5534   
 
 5535   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:119: ( drop )*
 5536  136 
                 while ( stream_drop.hasNext() ) {
 5537  8 
                     adaptor.addChild(root_0, stream_drop.nextTree());
 5538   
 
 5539   
                 }
 5540  128 
                 stream_drop.reset();
 5541   
 
 5542   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:125: ( add )*
 5543  128 
                 while ( stream_add.hasNext() ) {
 5544  0 
                     adaptor.addChild(root_0, stream_add.nextTree());
 5545   
 
 5546   
                 }
 5547  128 
                 stream_add.reset();
 5548   
 
 5549   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:130: ( move )*
 5550  128 
                 while ( stream_move.hasNext() ) {
 5551  0 
                     adaptor.addChild(root_0, stream_move.nextTree());
 5552   
 
 5553   
                 }
 5554  128 
                 stream_move.reset();
 5555   
 
 5556   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:136: ( copy )*
 5557  128 
                 while ( stream_copy.hasNext() ) {
 5558  0 
                     adaptor.addChild(root_0, stream_copy.nextTree());
 5559   
 
 5560   
                 }
 5561  128 
                 stream_copy.reset();
 5562   
 
 5563   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:142: ( create )*
 5564  128 
                 while ( stream_create.hasNext() ) {
 5565  0 
                     adaptor.addChild(root_0, stream_create.nextTree());
 5566   
 
 5567   
                 }
 5568  128 
                 stream_create.reset();
 5569   
 
 5570   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:150: ( insert )*
 5571  136 
                 while ( stream_insert.hasNext() ) {
 5572  8 
                     adaptor.addChild(root_0, stream_insert.nextTree());
 5573   
 
 5574   
                 }
 5575  128 
                 stream_insert.reset();
 5576   
 
 5577   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:158: ( delete )*
 5578  152 
                 while ( stream_delete.hasNext() ) {
 5579  24 
                     adaptor.addChild(root_0, stream_delete.nextTree());
 5580   
 
 5581   
                 }
 5582  128 
                 stream_delete.reset();
 5583   
 
 5584   
                 // com\\googlecode\\sparkleg\\Sparql.g:189:166: ( modify )*
 5585  208 
                 while ( stream_modify.hasNext() ) {
 5586  80 
                     adaptor.addChild(root_0, stream_modify.nextTree());
 5587   
 
 5588   
                 }
 5589  128 
                 stream_modify.reset();
 5590   
 
 5591   
             }
 5592   
 
 5593   
 
 5594  128 
             retval.tree = root_0;
 5595   
 
 5596   
             }
 5597   
 
 5598  128 
             retval.stop = input.LT(-1);
 5599   
 
 5600   
 
 5601  128 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5602  128 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5603   
 
 5604   
         }
 5605  0 
         catch (RecognitionException re) {
 5606  0 
             reportError(re);
 5607  0 
             recover(input,re);
 5608  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5609   
 
 5610   
         }
 5611   
 
 5612  0 
         finally {
 5613   
                 // do for sure before leaving
 5614  128 
         }
 5615  128 
         return retval;
 5616   
     }
 5617   
     // $ANTLR end "update"
 5618   
 
 5619   
 
 5620  0 
     public static class load_return extends ParserRuleReturnScope {
 5621   
         Object tree;
 5622  0 
         public Object getTree() { return tree; }
 5623   
     };
 5624   
 
 5625   
 
 5626   
     // $ANTLR start "load"
 5627   
     // com\\googlecode\\sparkleg\\Sparql.g:192:1: load : LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) ;
 5628   
     public final SparqlParser.load_return load() throws RecognitionException {
 5629  0 
         SparqlParser.load_return retval = new SparqlParser.load_return();
 5630  0 
         retval.start = input.LT(1);
 5631   
 
 5632   
 
 5633  0 
         Object root_0 = null;
 5634   
 
 5635  0 
         Token LOAD120=null;
 5636  0 
         Token SILENT121=null;
 5637  0 
         Token INTO123=null;
 5638  0 
         SparqlParser.iriRef_return iriRef122 =null;
 5639   
 
 5640  0 
         SparqlParser.graphRef_return graphRef124 =null;
 5641   
 
 5642   
 
 5643  0 
         Object LOAD120_tree=null;
 5644  0 
         Object SILENT121_tree=null;
 5645  0 
         Object INTO123_tree=null;
 5646  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5647  0 
         RewriteRuleTokenStream stream_INTO=new RewriteRuleTokenStream(adaptor,"token INTO");
 5648  0 
         RewriteRuleTokenStream stream_LOAD=new RewriteRuleTokenStream(adaptor,"token LOAD");
 5649  0 
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 5650  0 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 5651   
         try {
 5652   
             // com\\googlecode\\sparkleg\\Sparql.g:193:5: ( LOAD ( SILENT )? iriRef ( INTO graphRef )? -> ^( LOAD ( SILENT )* iriRef ( graphRef )? ) )
 5653   
             // com\\googlecode\\sparkleg\\Sparql.g:193:7: LOAD ( SILENT )? iriRef ( INTO graphRef )?
 5654   
             {
 5655  0 
             LOAD120=(Token)match(input,LOAD,FOLLOW_LOAD_in_load1433);
 5656  0 
             stream_LOAD.add(LOAD120);
 5657   
 
 5658   
 
 5659   
             // com\\googlecode\\sparkleg\\Sparql.g:193:12: ( SILENT )?
 5660  0 
             int alt41=2;
 5661  0 
             switch ( input.LA(1) ) {
 5662   
                 case SILENT:
 5663   
                     {
 5664  0 
                     alt41=1;
 5665   
                     }
 5666   
                     break;
 5667   
             }
 5668   
 
 5669  0 
             switch (alt41) {
 5670   
                 case 1 :
 5671   
                     // com\\googlecode\\sparkleg\\Sparql.g:193:12: SILENT
 5672   
                     {
 5673  0 
                     SILENT121=(Token)match(input,SILENT,FOLLOW_SILENT_in_load1435);
 5674  0 
                     stream_SILENT.add(SILENT121);
 5675   
 
 5676   
 
 5677   
                     }
 5678   
                     break;
 5679   
 
 5680   
             }
 5681   
 
 5682   
 
 5683  0 
             pushFollow(FOLLOW_iriRef_in_load1438);
 5684  0 
             iriRef122=iriRef();
 5685   
 
 5686  0 
             state._fsp--;
 5687   
 
 5688  0 
             stream_iriRef.add(iriRef122.getTree());
 5689   
 
 5690   
             // com\\googlecode\\sparkleg\\Sparql.g:193:27: ( INTO graphRef )?
 5691  0 
             int alt42=2;
 5692  0 
             switch ( input.LA(1) ) {
 5693   
                 case INTO:
 5694   
                     {
 5695  0 
                     alt42=1;
 5696   
                     }
 5697   
                     break;
 5698   
             }
 5699   
 
 5700  0 
             switch (alt42) {
 5701   
                 case 1 :
 5702   
                     // com\\googlecode\\sparkleg\\Sparql.g:193:28: INTO graphRef
 5703   
                     {
 5704  0 
                     INTO123=(Token)match(input,INTO,FOLLOW_INTO_in_load1441);
 5705  0 
                     stream_INTO.add(INTO123);
 5706   
 
 5707   
 
 5708  0 
                     pushFollow(FOLLOW_graphRef_in_load1443);
 5709  0 
                     graphRef124=graphRef();
 5710   
 
 5711  0 
                     state._fsp--;
 5712   
 
 5713  0 
                     stream_graphRef.add(graphRef124.getTree());
 5714   
 
 5715   
                     }
 5716   
                     break;
 5717   
 
 5718   
             }
 5719   
 
 5720   
 
 5721   
             // AST REWRITE
 5722   
             // elements: iriRef, LOAD, SILENT, graphRef
 5723   
             // token labels:
 5724   
             // rule labels: retval
 5725   
             // token list labels:
 5726   
             // rule list labels:
 5727   
             // wildcard labels:
 5728  0 
             retval.tree = root_0;
 5729  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5730   
 
 5731  0 
             root_0 = (Object)adaptor.nil();
 5732   
             // 193:44: -> ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5733   
             {
 5734   
                 // com\\googlecode\\sparkleg\\Sparql.g:193:47: ^( LOAD ( SILENT )* iriRef ( graphRef )? )
 5735   
                 {
 5736  0 
                 Object root_1 = (Object)adaptor.nil();
 5737  0 
                 root_1 = (Object)adaptor.becomeRoot(
 5738   
                 stream_LOAD.nextNode()
 5739   
                 , root_1);
 5740   
 
 5741   
                 // com\\googlecode\\sparkleg\\Sparql.g:193:54: ( SILENT )*
 5742  0 
                 while ( stream_SILENT.hasNext() ) {
 5743  0 
                     adaptor.addChild(root_1,
 5744   
                     stream_SILENT.nextNode()
 5745   
                     );
 5746   
 
 5747   
                 }
 5748  0 
                 stream_SILENT.reset();
 5749   
 
 5750  0 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 5751   
 
 5752   
                 // com\\googlecode\\sparkleg\\Sparql.g:193:69: ( graphRef )?
 5753  0 
                 if ( stream_graphRef.hasNext() ) {
 5754  0 
                     adaptor.addChild(root_1, stream_graphRef.nextTree());
 5755   
 
 5756   
                 }
 5757  0 
                 stream_graphRef.reset();
 5758   
 
 5759  0 
                 adaptor.addChild(root_0, root_1);
 5760   
                 }
 5761   
 
 5762   
             }
 5763   
 
 5764   
 
 5765  0 
             retval.tree = root_0;
 5766   
 
 5767   
             }
 5768   
 
 5769  0 
             retval.stop = input.LT(-1);
 5770   
 
 5771   
 
 5772  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5773  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5774   
 
 5775   
         }
 5776  0 
         catch (RecognitionException re) {
 5777  0 
             reportError(re);
 5778  0 
             recover(input,re);
 5779  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5780   
 
 5781   
         }
 5782   
 
 5783  0 
         finally {
 5784   
                 // do for sure before leaving
 5785  0 
         }
 5786  0 
         return retval;
 5787   
     }
 5788   
     // $ANTLR end "load"
 5789   
 
 5790   
 
 5791  8 
     public static class clear_return extends ParserRuleReturnScope {
 5792   
         Object tree;
 5793  8 
         public Object getTree() { return tree; }
 5794   
     };
 5795   
 
 5796   
 
 5797   
     // $ANTLR start "clear"
 5798   
     // com\\googlecode\\sparkleg\\Sparql.g:196:1: clear : CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) ;
 5799   
     public final SparqlParser.clear_return clear() throws RecognitionException {
 5800  8 
         SparqlParser.clear_return retval = new SparqlParser.clear_return();
 5801  8 
         retval.start = input.LT(1);
 5802   
 
 5803   
 
 5804  8 
         Object root_0 = null;
 5805   
 
 5806  8 
         Token CLEAR125=null;
 5807  8 
         Token SILENT126=null;
 5808  8 
         SparqlParser.graphRefAll_return graphRefAll127 =null;
 5809   
 
 5810   
 
 5811  8 
         Object CLEAR125_tree=null;
 5812  8 
         Object SILENT126_tree=null;
 5813  8 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5814  8 
         RewriteRuleTokenStream stream_CLEAR=new RewriteRuleTokenStream(adaptor,"token CLEAR");
 5815  8 
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5816   
         try {
 5817   
             // com\\googlecode\\sparkleg\\Sparql.g:197:5: ( CLEAR ( SILENT )? graphRefAll -> ^( CLEAR ( SILENT )* graphRefAll ) )
 5818   
             // com\\googlecode\\sparkleg\\Sparql.g:197:7: CLEAR ( SILENT )? graphRefAll
 5819   
             {
 5820  8 
             CLEAR125=(Token)match(input,CLEAR,FOLLOW_CLEAR_in_clear1480);
 5821  8 
             stream_CLEAR.add(CLEAR125);
 5822   
 
 5823   
 
 5824   
             // com\\googlecode\\sparkleg\\Sparql.g:197:14: ( SILENT )?
 5825  8 
             int alt43=2;
 5826  8 
             switch ( input.LA(1) ) {
 5827   
                 case SILENT:
 5828   
                     {
 5829  0 
                     alt43=1;
 5830   
                     }
 5831   
                     break;
 5832   
             }
 5833   
 
 5834  8 
             switch (alt43) {
 5835   
                 case 1 :
 5836   
                     // com\\googlecode\\sparkleg\\Sparql.g:197:14: SILENT
 5837   
                     {
 5838  0 
                     SILENT126=(Token)match(input,SILENT,FOLLOW_SILENT_in_clear1483);
 5839  0 
                     stream_SILENT.add(SILENT126);
 5840   
 
 5841   
 
 5842   
                     }
 5843   
                     break;
 5844   
 
 5845   
             }
 5846   
 
 5847   
 
 5848  8 
             pushFollow(FOLLOW_graphRefAll_in_clear1486);
 5849  8 
             graphRefAll127=graphRefAll();
 5850   
 
 5851  8 
             state._fsp--;
 5852   
 
 5853  8 
             stream_graphRefAll.add(graphRefAll127.getTree());
 5854   
 
 5855   
             // AST REWRITE
 5856   
             // elements: SILENT, graphRefAll, CLEAR
 5857   
             // token labels:
 5858   
             // rule labels: retval
 5859   
             // token list labels:
 5860   
             // rule list labels:
 5861   
             // wildcard labels:
 5862  8 
             retval.tree = root_0;
 5863  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5864   
 
 5865  8 
             root_0 = (Object)adaptor.nil();
 5866   
             // 197:34: -> ^( CLEAR ( SILENT )* graphRefAll )
 5867   
             {
 5868   
                 // com\\googlecode\\sparkleg\\Sparql.g:197:37: ^( CLEAR ( SILENT )* graphRefAll )
 5869   
                 {
 5870  8 
                 Object root_1 = (Object)adaptor.nil();
 5871  8 
                 root_1 = (Object)adaptor.becomeRoot(
 5872   
                 stream_CLEAR.nextNode()
 5873   
                 , root_1);
 5874   
 
 5875   
                 // com\\googlecode\\sparkleg\\Sparql.g:197:45: ( SILENT )*
 5876  8 
                 while ( stream_SILENT.hasNext() ) {
 5877  0 
                     adaptor.addChild(root_1,
 5878   
                     stream_SILENT.nextNode()
 5879   
                     );
 5880   
 
 5881   
                 }
 5882  8 
                 stream_SILENT.reset();
 5883   
 
 5884  8 
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 5885   
 
 5886  8 
                 adaptor.addChild(root_0, root_1);
 5887   
                 }
 5888   
 
 5889   
             }
 5890   
 
 5891   
 
 5892  8 
             retval.tree = root_0;
 5893   
 
 5894   
             }
 5895   
 
 5896  8 
             retval.stop = input.LT(-1);
 5897   
 
 5898   
 
 5899  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 5900  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 5901   
 
 5902   
         }
 5903  0 
         catch (RecognitionException re) {
 5904  0 
             reportError(re);
 5905  0 
             recover(input,re);
 5906  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 5907   
 
 5908   
         }
 5909   
 
 5910  0 
         finally {
 5911   
                 // do for sure before leaving
 5912  8 
         }
 5913  8 
         return retval;
 5914   
     }
 5915   
     // $ANTLR end "clear"
 5916   
 
 5917   
 
 5918  8 
     public static class drop_return extends ParserRuleReturnScope {
 5919   
         Object tree;
 5920  8 
         public Object getTree() { return tree; }
 5921   
     };
 5922   
 
 5923   
 
 5924   
     // $ANTLR start "drop"
 5925   
     // com\\googlecode\\sparkleg\\Sparql.g:200:1: drop : DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) ;
 5926   
     public final SparqlParser.drop_return drop() throws RecognitionException {
 5927  8 
         SparqlParser.drop_return retval = new SparqlParser.drop_return();
 5928  8 
         retval.start = input.LT(1);
 5929   
 
 5930   
 
 5931  8 
         Object root_0 = null;
 5932   
 
 5933  8 
         Token DROP128=null;
 5934  8 
         Token SILENT129=null;
 5935  8 
         SparqlParser.graphRefAll_return graphRefAll130 =null;
 5936   
 
 5937   
 
 5938  8 
         Object DROP128_tree=null;
 5939  8 
         Object SILENT129_tree=null;
 5940  8 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 5941  8 
         RewriteRuleTokenStream stream_DROP=new RewriteRuleTokenStream(adaptor,"token DROP");
 5942  8 
         RewriteRuleSubtreeStream stream_graphRefAll=new RewriteRuleSubtreeStream(adaptor,"rule graphRefAll");
 5943   
         try {
 5944   
             // com\\googlecode\\sparkleg\\Sparql.g:201:5: ( DROP ( SILENT )? graphRefAll -> ^( DROP ( SILENT )* graphRefAll ) )
 5945   
             // com\\googlecode\\sparkleg\\Sparql.g:201:7: DROP ( SILENT )? graphRefAll
 5946   
             {
 5947  8 
             DROP128=(Token)match(input,DROP,FOLLOW_DROP_in_drop1518);
 5948  8 
             stream_DROP.add(DROP128);
 5949   
 
 5950   
 
 5951   
             // com\\googlecode\\sparkleg\\Sparql.g:201:12: ( SILENT )?
 5952  8 
             int alt44=2;
 5953  8 
             switch ( input.LA(1) ) {
 5954   
                 case SILENT:
 5955   
                     {
 5956  0 
                     alt44=1;
 5957   
                     }
 5958   
                     break;
 5959   
             }
 5960   
 
 5961  8 
             switch (alt44) {
 5962   
                 case 1 :
 5963   
                     // com\\googlecode\\sparkleg\\Sparql.g:201:12: SILENT
 5964   
                     {
 5965  0 
                     SILENT129=(Token)match(input,SILENT,FOLLOW_SILENT_in_drop1520);
 5966  0 
                     stream_SILENT.add(SILENT129);
 5967   
 
 5968   
 
 5969   
                     }
 5970   
                     break;
 5971   
 
 5972   
             }
 5973   
 
 5974   
 
 5975  8 
             pushFollow(FOLLOW_graphRefAll_in_drop1523);
 5976  8 
             graphRefAll130=graphRefAll();
 5977   
 
 5978  8 
             state._fsp--;
 5979   
 
 5980  8 
             stream_graphRefAll.add(graphRefAll130.getTree());
 5981   
 
 5982   
             // AST REWRITE
 5983   
             // elements: SILENT, DROP, graphRefAll
 5984   
             // token labels:
 5985   
             // rule labels: retval
 5986   
             // token list labels:
 5987   
             // rule list labels:
 5988   
             // wildcard labels:
 5989  8 
             retval.tree = root_0;
 5990  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 5991   
 
 5992  8 
             root_0 = (Object)adaptor.nil();
 5993   
             // 201:32: -> ^( DROP ( SILENT )* graphRefAll )
 5994   
             {
 5995   
                 // com\\googlecode\\sparkleg\\Sparql.g:201:35: ^( DROP ( SILENT )* graphRefAll )
 5996   
                 {
 5997  8 
                 Object root_1 = (Object)adaptor.nil();
 5998  8 
                 root_1 = (Object)adaptor.becomeRoot(
 5999   
                 stream_DROP.nextNode()
 6000   
                 , root_1);
 6001   
 
 6002   
                 // com\\googlecode\\sparkleg\\Sparql.g:201:42: ( SILENT )*
 6003  8 
                 while ( stream_SILENT.hasNext() ) {
 6004  0 
                     adaptor.addChild(root_1,
 6005   
                     stream_SILENT.nextNode()
 6006   
                     );
 6007   
 
 6008   
                 }
 6009  8 
                 stream_SILENT.reset();
 6010   
 
 6011  8 
                 adaptor.addChild(root_1, stream_graphRefAll.nextTree());
 6012   
 
 6013  8 
                 adaptor.addChild(root_0, root_1);
 6014   
                 }
 6015   
 
 6016   
             }
 6017   
 
 6018   
 
 6019  8 
             retval.tree = root_0;
 6020   
 
 6021   
             }
 6022   
 
 6023  8 
             retval.stop = input.LT(-1);
 6024   
 
 6025   
 
 6026  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6027  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6028   
 
 6029   
         }
 6030  0 
         catch (RecognitionException re) {
 6031  0 
             reportError(re);
 6032  0 
             recover(input,re);
 6033  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6034   
 
 6035   
         }
 6036   
 
 6037  0 
         finally {
 6038   
                 // do for sure before leaving
 6039  8 
         }
 6040  8 
         return retval;
 6041   
     }
 6042   
     // $ANTLR end "drop"
 6043   
 
 6044   
 
 6045  0 
     public static class create_return extends ParserRuleReturnScope {
 6046   
         Object tree;
 6047  0 
         public Object getTree() { return tree; }
 6048   
     };
 6049   
 
 6050   
 
 6051   
     // $ANTLR start "create"
 6052   
     // com\\googlecode\\sparkleg\\Sparql.g:204:1: create : CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) ;
 6053   
     public final SparqlParser.create_return create() throws RecognitionException {
 6054  0 
         SparqlParser.create_return retval = new SparqlParser.create_return();
 6055  0 
         retval.start = input.LT(1);
 6056   
 
 6057   
 
 6058  0 
         Object root_0 = null;
 6059   
 
 6060  0 
         Token CREATE131=null;
 6061  0 
         Token SILENT132=null;
 6062  0 
         SparqlParser.graphRef_return graphRef133 =null;
 6063   
 
 6064   
 
 6065  0 
         Object CREATE131_tree=null;
 6066  0 
         Object SILENT132_tree=null;
 6067  0 
         RewriteRuleTokenStream stream_CREATE=new RewriteRuleTokenStream(adaptor,"token CREATE");
 6068  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6069  0 
         RewriteRuleSubtreeStream stream_graphRef=new RewriteRuleSubtreeStream(adaptor,"rule graphRef");
 6070   
         try {
 6071   
             // com\\googlecode\\sparkleg\\Sparql.g:205:5: ( CREATE ( SILENT )? graphRef -> ^( CREATE ( SILENT )* graphRef ) )
 6072   
             // com\\googlecode\\sparkleg\\Sparql.g:205:7: CREATE ( SILENT )? graphRef
 6073   
             {
 6074  0 
             CREATE131=(Token)match(input,CREATE,FOLLOW_CREATE_in_create1552);
 6075  0 
             stream_CREATE.add(CREATE131);
 6076   
 
 6077   
 
 6078   
             // com\\googlecode\\sparkleg\\Sparql.g:205:14: ( SILENT )?
 6079  0 
             int alt45=2;
 6080  0 
             switch ( input.LA(1) ) {
 6081   
                 case SILENT:
 6082   
                     {
 6083  0 
                     alt45=1;
 6084   
                     }
 6085   
                     break;
 6086   
             }
 6087   
 
 6088  0 
             switch (alt45) {
 6089   
                 case 1 :
 6090   
                     // com\\googlecode\\sparkleg\\Sparql.g:205:14: SILENT
 6091   
                     {
 6092  0 
                     SILENT132=(Token)match(input,SILENT,FOLLOW_SILENT_in_create1554);
 6093  0 
                     stream_SILENT.add(SILENT132);
 6094   
 
 6095   
 
 6096   
                     }
 6097   
                     break;
 6098   
 
 6099   
             }
 6100   
 
 6101   
 
 6102  0 
             pushFollow(FOLLOW_graphRef_in_create1557);
 6103  0 
             graphRef133=graphRef();
 6104   
 
 6105  0 
             state._fsp--;
 6106   
 
 6107  0 
             stream_graphRef.add(graphRef133.getTree());
 6108   
 
 6109   
             // AST REWRITE
 6110   
             // elements: SILENT, graphRef, CREATE
 6111   
             // token labels:
 6112   
             // rule labels: retval
 6113   
             // token list labels:
 6114   
             // rule list labels:
 6115   
             // wildcard labels:
 6116  0 
             retval.tree = root_0;
 6117  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6118   
 
 6119  0 
             root_0 = (Object)adaptor.nil();
 6120   
             // 205:31: -> ^( CREATE ( SILENT )* graphRef )
 6121   
             {
 6122   
                 // com\\googlecode\\sparkleg\\Sparql.g:205:34: ^( CREATE ( SILENT )* graphRef )
 6123   
                 {
 6124  0 
                 Object root_1 = (Object)adaptor.nil();
 6125  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6126   
                 stream_CREATE.nextNode()
 6127   
                 , root_1);
 6128   
 
 6129   
                 // com\\googlecode\\sparkleg\\Sparql.g:205:43: ( SILENT )*
 6130  0 
                 while ( stream_SILENT.hasNext() ) {
 6131  0 
                     adaptor.addChild(root_1,
 6132   
                     stream_SILENT.nextNode()
 6133   
                     );
 6134   
 
 6135   
                 }
 6136  0 
                 stream_SILENT.reset();
 6137   
 
 6138  0 
                 adaptor.addChild(root_1, stream_graphRef.nextTree());
 6139   
 
 6140  0 
                 adaptor.addChild(root_0, root_1);
 6141   
                 }
 6142   
 
 6143   
             }
 6144   
 
 6145   
 
 6146  0 
             retval.tree = root_0;
 6147   
 
 6148   
             }
 6149   
 
 6150  0 
             retval.stop = input.LT(-1);
 6151   
 
 6152   
 
 6153  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6154  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6155   
 
 6156   
         }
 6157  0 
         catch (RecognitionException re) {
 6158  0 
             reportError(re);
 6159  0 
             recover(input,re);
 6160  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6161   
 
 6162   
         }
 6163   
 
 6164  0 
         finally {
 6165   
                 // do for sure before leaving
 6166  0 
         }
 6167  0 
         return retval;
 6168   
     }
 6169   
     // $ANTLR end "create"
 6170   
 
 6171   
 
 6172  0 
     public static class add_return extends ParserRuleReturnScope {
 6173   
         Object tree;
 6174  0 
         public Object getTree() { return tree; }
 6175   
     };
 6176   
 
 6177   
 
 6178   
     // $ANTLR start "add"
 6179   
     // com\\googlecode\\sparkleg\\Sparql.g:208:1: add : ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) ;
 6180   
     public final SparqlParser.add_return add() throws RecognitionException {
 6181  0 
         SparqlParser.add_return retval = new SparqlParser.add_return();
 6182  0 
         retval.start = input.LT(1);
 6183   
 
 6184   
 
 6185  0 
         Object root_0 = null;
 6186   
 
 6187  0 
         Token ADD134=null;
 6188  0 
         Token SILENT135=null;
 6189  0 
         Token TO136=null;
 6190  0 
         SparqlParser.graphOrDefault_return from =null;
 6191   
 
 6192  0 
         SparqlParser.graphOrDefault_return to =null;
 6193   
 
 6194   
 
 6195  0 
         Object ADD134_tree=null;
 6196  0 
         Object SILENT135_tree=null;
 6197  0 
         Object TO136_tree=null;
 6198  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6199  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6200  0 
         RewriteRuleTokenStream stream_ADD=new RewriteRuleTokenStream(adaptor,"token ADD");
 6201  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6202   
         try {
 6203   
             // com\\googlecode\\sparkleg\\Sparql.g:209:5: ( ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( ADD ( SILENT )* $from $to) )
 6204   
             // com\\googlecode\\sparkleg\\Sparql.g:209:7: ADD ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6205   
             {
 6206  0 
             ADD134=(Token)match(input,ADD,FOLLOW_ADD_in_add1589);
 6207  0 
             stream_ADD.add(ADD134);
 6208   
 
 6209   
 
 6210   
             // com\\googlecode\\sparkleg\\Sparql.g:209:11: ( SILENT )?
 6211  0 
             int alt46=2;
 6212  0 
             switch ( input.LA(1) ) {
 6213   
                 case SILENT:
 6214   
                     {
 6215  0 
                     alt46=1;
 6216   
                     }
 6217   
                     break;
 6218   
             }
 6219   
 
 6220  0 
             switch (alt46) {
 6221   
                 case 1 :
 6222   
                     // com\\googlecode\\sparkleg\\Sparql.g:209:11: SILENT
 6223   
                     {
 6224  0 
                     SILENT135=(Token)match(input,SILENT,FOLLOW_SILENT_in_add1591);
 6225  0 
                     stream_SILENT.add(SILENT135);
 6226   
 
 6227   
 
 6228   
                     }
 6229   
                     break;
 6230   
 
 6231   
             }
 6232   
 
 6233   
 
 6234  0 
             pushFollow(FOLLOW_graphOrDefault_in_add1596);
 6235  0 
             from=graphOrDefault();
 6236   
 
 6237  0 
             state._fsp--;
 6238   
 
 6239  0 
             stream_graphOrDefault.add(from.getTree());
 6240   
 
 6241  0 
             TO136=(Token)match(input,TO,FOLLOW_TO_in_add1598);
 6242  0 
             stream_TO.add(TO136);
 6243   
 
 6244   
 
 6245  0 
             pushFollow(FOLLOW_graphOrDefault_in_add1602);
 6246  0 
             to=graphOrDefault();
 6247   
 
 6248  0 
             state._fsp--;
 6249   
 
 6250  0 
             stream_graphOrDefault.add(to.getTree());
 6251   
 
 6252   
             // AST REWRITE
 6253   
             // elements: to, ADD, SILENT, from
 6254   
             // token labels:
 6255   
             // rule labels: to, retval, from
 6256   
             // token list labels:
 6257   
             // rule list labels:
 6258   
             // wildcard labels:
 6259  0 
             retval.tree = root_0;
 6260  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6261  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6262  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6263   
 
 6264  0 
             root_0 = (Object)adaptor.nil();
 6265   
             // 209:60: -> ^( ADD ( SILENT )* $from $to)
 6266   
             {
 6267   
                 // com\\googlecode\\sparkleg\\Sparql.g:209:63: ^( ADD ( SILENT )* $from $to)
 6268   
                 {
 6269  0 
                 Object root_1 = (Object)adaptor.nil();
 6270  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6271   
                 stream_ADD.nextNode()
 6272   
                 , root_1);
 6273   
 
 6274   
                 // com\\googlecode\\sparkleg\\Sparql.g:209:69: ( SILENT )*
 6275  0 
                 while ( stream_SILENT.hasNext() ) {
 6276  0 
                     adaptor.addChild(root_1,
 6277   
                     stream_SILENT.nextNode()
 6278   
                     );
 6279   
 
 6280   
                 }
 6281  0 
                 stream_SILENT.reset();
 6282   
 
 6283  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6284   
 
 6285  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6286   
 
 6287  0 
                 adaptor.addChild(root_0, root_1);
 6288   
                 }
 6289   
 
 6290   
             }
 6291   
 
 6292   
 
 6293  0 
             retval.tree = root_0;
 6294   
 
 6295   
             }
 6296   
 
 6297  0 
             retval.stop = input.LT(-1);
 6298   
 
 6299   
 
 6300  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6301  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6302   
 
 6303   
         }
 6304  0 
         catch (RecognitionException re) {
 6305  0 
             reportError(re);
 6306  0 
             recover(input,re);
 6307  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6308   
 
 6309   
         }
 6310   
 
 6311  0 
         finally {
 6312   
                 // do for sure before leaving
 6313  0 
         }
 6314  0 
         return retval;
 6315   
     }
 6316   
     // $ANTLR end "add"
 6317   
 
 6318   
 
 6319  0 
     public static class move_return extends ParserRuleReturnScope {
 6320   
         Object tree;
 6321  0 
         public Object getTree() { return tree; }
 6322   
     };
 6323   
 
 6324   
 
 6325   
     // $ANTLR start "move"
 6326   
     // com\\googlecode\\sparkleg\\Sparql.g:212:1: move : MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) ;
 6327   
     public final SparqlParser.move_return move() throws RecognitionException {
 6328  0 
         SparqlParser.move_return retval = new SparqlParser.move_return();
 6329  0 
         retval.start = input.LT(1);
 6330   
 
 6331   
 
 6332  0 
         Object root_0 = null;
 6333   
 
 6334  0 
         Token MOVE137=null;
 6335  0 
         Token SILENT138=null;
 6336  0 
         Token TO139=null;
 6337  0 
         SparqlParser.graphOrDefault_return from =null;
 6338   
 
 6339  0 
         SparqlParser.graphOrDefault_return to =null;
 6340   
 
 6341   
 
 6342  0 
         Object MOVE137_tree=null;
 6343  0 
         Object SILENT138_tree=null;
 6344  0 
         Object TO139_tree=null;
 6345  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6346  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6347  0 
         RewriteRuleTokenStream stream_MOVE=new RewriteRuleTokenStream(adaptor,"token MOVE");
 6348  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6349   
         try {
 6350   
             // com\\googlecode\\sparkleg\\Sparql.g:213:5: ( MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( MOVE ( SILENT )* $from $to) )
 6351   
             // com\\googlecode\\sparkleg\\Sparql.g:213:7: MOVE ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6352   
             {
 6353  0 
             MOVE137=(Token)match(input,MOVE,FOLLOW_MOVE_in_move1638);
 6354  0 
             stream_MOVE.add(MOVE137);
 6355   
 
 6356   
 
 6357   
             // com\\googlecode\\sparkleg\\Sparql.g:213:12: ( SILENT )?
 6358  0 
             int alt47=2;
 6359  0 
             switch ( input.LA(1) ) {
 6360   
                 case SILENT:
 6361   
                     {
 6362  0 
                     alt47=1;
 6363   
                     }
 6364   
                     break;
 6365   
             }
 6366   
 
 6367  0 
             switch (alt47) {
 6368   
                 case 1 :
 6369   
                     // com\\googlecode\\sparkleg\\Sparql.g:213:12: SILENT
 6370   
                     {
 6371  0 
                     SILENT138=(Token)match(input,SILENT,FOLLOW_SILENT_in_move1640);
 6372  0 
                     stream_SILENT.add(SILENT138);
 6373   
 
 6374   
 
 6375   
                     }
 6376   
                     break;
 6377   
 
 6378   
             }
 6379   
 
 6380   
 
 6381  0 
             pushFollow(FOLLOW_graphOrDefault_in_move1645);
 6382  0 
             from=graphOrDefault();
 6383   
 
 6384  0 
             state._fsp--;
 6385   
 
 6386  0 
             stream_graphOrDefault.add(from.getTree());
 6387   
 
 6388  0 
             TO139=(Token)match(input,TO,FOLLOW_TO_in_move1647);
 6389  0 
             stream_TO.add(TO139);
 6390   
 
 6391   
 
 6392  0 
             pushFollow(FOLLOW_graphOrDefault_in_move1651);
 6393  0 
             to=graphOrDefault();
 6394   
 
 6395  0 
             state._fsp--;
 6396   
 
 6397  0 
             stream_graphOrDefault.add(to.getTree());
 6398   
 
 6399   
             // AST REWRITE
 6400   
             // elements: from, SILENT, MOVE, to
 6401   
             // token labels:
 6402   
             // rule labels: to, retval, from
 6403   
             // token list labels:
 6404   
             // rule list labels:
 6405   
             // wildcard labels:
 6406  0 
             retval.tree = root_0;
 6407  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6408  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6409  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6410   
 
 6411  0 
             root_0 = (Object)adaptor.nil();
 6412   
             // 213:61: -> ^( MOVE ( SILENT )* $from $to)
 6413   
             {
 6414   
                 // com\\googlecode\\sparkleg\\Sparql.g:213:64: ^( MOVE ( SILENT )* $from $to)
 6415   
                 {
 6416  0 
                 Object root_1 = (Object)adaptor.nil();
 6417  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6418   
                 stream_MOVE.nextNode()
 6419   
                 , root_1);
 6420   
 
 6421   
                 // com\\googlecode\\sparkleg\\Sparql.g:213:71: ( SILENT )*
 6422  0 
                 while ( stream_SILENT.hasNext() ) {
 6423  0 
                     adaptor.addChild(root_1,
 6424   
                     stream_SILENT.nextNode()
 6425   
                     );
 6426   
 
 6427   
                 }
 6428  0 
                 stream_SILENT.reset();
 6429   
 
 6430  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6431   
 
 6432  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6433   
 
 6434  0 
                 adaptor.addChild(root_0, root_1);
 6435   
                 }
 6436   
 
 6437   
             }
 6438   
 
 6439   
 
 6440  0 
             retval.tree = root_0;
 6441   
 
 6442   
             }
 6443   
 
 6444  0 
             retval.stop = input.LT(-1);
 6445   
 
 6446   
 
 6447  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6448  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6449   
 
 6450   
         }
 6451  0 
         catch (RecognitionException re) {
 6452  0 
             reportError(re);
 6453  0 
             recover(input,re);
 6454  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6455   
 
 6456   
         }
 6457   
 
 6458  0 
         finally {
 6459   
                 // do for sure before leaving
 6460  0 
         }
 6461  0 
         return retval;
 6462   
     }
 6463   
     // $ANTLR end "move"
 6464   
 
 6465   
 
 6466  0 
     public static class copy_return extends ParserRuleReturnScope {
 6467   
         Object tree;
 6468  0 
         public Object getTree() { return tree; }
 6469   
     };
 6470   
 
 6471   
 
 6472   
     // $ANTLR start "copy"
 6473   
     // com\\googlecode\\sparkleg\\Sparql.g:216:1: copy : COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) ;
 6474   
     public final SparqlParser.copy_return copy() throws RecognitionException {
 6475  0 
         SparqlParser.copy_return retval = new SparqlParser.copy_return();
 6476  0 
         retval.start = input.LT(1);
 6477   
 
 6478   
 
 6479  0 
         Object root_0 = null;
 6480   
 
 6481  0 
         Token COPY140=null;
 6482  0 
         Token SILENT141=null;
 6483  0 
         Token TO142=null;
 6484  0 
         SparqlParser.graphOrDefault_return from =null;
 6485   
 
 6486  0 
         SparqlParser.graphOrDefault_return to =null;
 6487   
 
 6488   
 
 6489  0 
         Object COPY140_tree=null;
 6490  0 
         Object SILENT141_tree=null;
 6491  0 
         Object TO142_tree=null;
 6492  0 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 6493  0 
         RewriteRuleTokenStream stream_TO=new RewriteRuleTokenStream(adaptor,"token TO");
 6494  0 
         RewriteRuleTokenStream stream_COPY=new RewriteRuleTokenStream(adaptor,"token COPY");
 6495  0 
         RewriteRuleSubtreeStream stream_graphOrDefault=new RewriteRuleSubtreeStream(adaptor,"rule graphOrDefault");
 6496   
         try {
 6497   
             // com\\googlecode\\sparkleg\\Sparql.g:217:5: ( COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault -> ^( COPY ( SILENT )* $from $to) )
 6498   
             // com\\googlecode\\sparkleg\\Sparql.g:217:7: COPY ( SILENT )? from= graphOrDefault TO to= graphOrDefault
 6499   
             {
 6500  0 
             COPY140=(Token)match(input,COPY,FOLLOW_COPY_in_copy1687);
 6501  0 
             stream_COPY.add(COPY140);
 6502   
 
 6503   
 
 6504   
             // com\\googlecode\\sparkleg\\Sparql.g:217:12: ( SILENT )?
 6505  0 
             int alt48=2;
 6506  0 
             switch ( input.LA(1) ) {
 6507   
                 case SILENT:
 6508   
                     {
 6509  0 
                     alt48=1;
 6510   
                     }
 6511   
                     break;
 6512   
             }
 6513   
 
 6514  0 
             switch (alt48) {
 6515   
                 case 1 :
 6516   
                     // com\\googlecode\\sparkleg\\Sparql.g:217:12: SILENT
 6517   
                     {
 6518  0 
                     SILENT141=(Token)match(input,SILENT,FOLLOW_SILENT_in_copy1689);
 6519  0 
                     stream_SILENT.add(SILENT141);
 6520   
 
 6521   
 
 6522   
                     }
 6523   
                     break;
 6524   
 
 6525   
             }
 6526   
 
 6527   
 
 6528  0 
             pushFollow(FOLLOW_graphOrDefault_in_copy1694);
 6529  0 
             from=graphOrDefault();
 6530   
 
 6531  0 
             state._fsp--;
 6532   
 
 6533  0 
             stream_graphOrDefault.add(from.getTree());
 6534   
 
 6535  0 
             TO142=(Token)match(input,TO,FOLLOW_TO_in_copy1696);
 6536  0 
             stream_TO.add(TO142);
 6537   
 
 6538   
 
 6539  0 
             pushFollow(FOLLOW_graphOrDefault_in_copy1700);
 6540  0 
             to=graphOrDefault();
 6541   
 
 6542  0 
             state._fsp--;
 6543   
 
 6544  0 
             stream_graphOrDefault.add(to.getTree());
 6545   
 
 6546   
             // AST REWRITE
 6547   
             // elements: SILENT, to, COPY, from
 6548   
             // token labels:
 6549   
             // rule labels: to, retval, from
 6550   
             // token list labels:
 6551   
             // rule list labels:
 6552   
             // wildcard labels:
 6553  0 
             retval.tree = root_0;
 6554  0 
             RewriteRuleSubtreeStream stream_to=new RewriteRuleSubtreeStream(adaptor,"rule to",to!=null?to.tree:null);
 6555  0 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6556  0 
             RewriteRuleSubtreeStream stream_from=new RewriteRuleSubtreeStream(adaptor,"rule from",from!=null?from.tree:null);
 6557   
 
 6558  0 
             root_0 = (Object)adaptor.nil();
 6559   
             // 217:61: -> ^( COPY ( SILENT )* $from $to)
 6560   
             {
 6561   
                 // com\\googlecode\\sparkleg\\Sparql.g:217:64: ^( COPY ( SILENT )* $from $to)
 6562   
                 {
 6563  0 
                 Object root_1 = (Object)adaptor.nil();
 6564  0 
                 root_1 = (Object)adaptor.becomeRoot(
 6565   
                 stream_COPY.nextNode()
 6566   
                 , root_1);
 6567   
 
 6568   
                 // com\\googlecode\\sparkleg\\Sparql.g:217:71: ( SILENT )*
 6569  0 
                 while ( stream_SILENT.hasNext() ) {
 6570  0 
                     adaptor.addChild(root_1,
 6571   
                     stream_SILENT.nextNode()
 6572   
                     );
 6573   
 
 6574   
                 }
 6575  0 
                 stream_SILENT.reset();
 6576   
 
 6577  0 
                 adaptor.addChild(root_1, stream_from.nextTree());
 6578   
 
 6579  0 
                 adaptor.addChild(root_1, stream_to.nextTree());
 6580   
 
 6581  0 
                 adaptor.addChild(root_0, root_1);
 6582   
                 }
 6583   
 
 6584   
             }
 6585   
 
 6586   
 
 6587  0 
             retval.tree = root_0;
 6588   
 
 6589   
             }
 6590   
 
 6591  0 
             retval.stop = input.LT(-1);
 6592   
 
 6593   
 
 6594  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6595  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6596   
 
 6597   
         }
 6598  0 
         catch (RecognitionException re) {
 6599  0 
             reportError(re);
 6600  0 
             recover(input,re);
 6601  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6602   
 
 6603   
         }
 6604   
 
 6605  0 
         finally {
 6606   
                 // do for sure before leaving
 6607  0 
         }
 6608  0 
         return retval;
 6609   
     }
 6610   
     // $ANTLR end "copy"
 6611   
 
 6612   
 
 6613  8 
     public static class insert_return extends ParserRuleReturnScope {
 6614   
         Object tree;
 6615  8 
         public Object getTree() { return tree; }
 6616   
     };
 6617   
 
 6618   
 
 6619   
     // $ANTLR start "insert"
 6620   
     // com\\googlecode\\sparkleg\\Sparql.g:220:1: insert : INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) ;
 6621   
     public final SparqlParser.insert_return insert() throws RecognitionException {
 6622  8 
         SparqlParser.insert_return retval = new SparqlParser.insert_return();
 6623  8 
         retval.start = input.LT(1);
 6624   
 
 6625   
 
 6626  8 
         Object root_0 = null;
 6627   
 
 6628  8 
         Token INSERT143=null;
 6629  8 
         Token DATA144=null;
 6630  8 
         SparqlParser.quadPattern_return quadPattern145 =null;
 6631   
 
 6632   
 
 6633  8 
         Object INSERT143_tree=null;
 6634  8 
         Object DATA144_tree=null;
 6635  8 
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 6636  8 
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6637  8 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6638   
         try {
 6639   
             // com\\googlecode\\sparkleg\\Sparql.g:221:5: ( INSERT DATA quadPattern -> ^( INSERT DATA quadPattern ) )
 6640   
             // com\\googlecode\\sparkleg\\Sparql.g:221:7: INSERT DATA quadPattern
 6641   
             {
 6642  8 
             INSERT143=(Token)match(input,INSERT,FOLLOW_INSERT_in_insert1732);
 6643  8 
             stream_INSERT.add(INSERT143);
 6644   
 
 6645   
 
 6646  8 
             DATA144=(Token)match(input,DATA,FOLLOW_DATA_in_insert1734);
 6647  8 
             stream_DATA.add(DATA144);
 6648   
 
 6649   
 
 6650  8 
             pushFollow(FOLLOW_quadPattern_in_insert1736);
 6651  8 
             quadPattern145=quadPattern();
 6652   
 
 6653  8 
             state._fsp--;
 6654   
 
 6655  8 
             stream_quadPattern.add(quadPattern145.getTree());
 6656   
 
 6657   
             // AST REWRITE
 6658   
             // elements: quadPattern, INSERT, DATA
 6659   
             // token labels:
 6660   
             // rule labels: retval
 6661   
             // token list labels:
 6662   
             // rule list labels:
 6663   
             // wildcard labels:
 6664  8 
             retval.tree = root_0;
 6665  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6666   
 
 6667  8 
             root_0 = (Object)adaptor.nil();
 6668   
             // 221:31: -> ^( INSERT DATA quadPattern )
 6669   
             {
 6670   
                 // com\\googlecode\\sparkleg\\Sparql.g:221:34: ^( INSERT DATA quadPattern )
 6671   
                 {
 6672  8 
                 Object root_1 = (Object)adaptor.nil();
 6673  8 
                 root_1 = (Object)adaptor.becomeRoot(
 6674   
                 stream_INSERT.nextNode()
 6675   
                 , root_1);
 6676   
 
 6677  8 
                 adaptor.addChild(root_1,
 6678   
                 stream_DATA.nextNode()
 6679   
                 );
 6680   
 
 6681  8 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6682   
 
 6683  8 
                 adaptor.addChild(root_0, root_1);
 6684   
                 }
 6685   
 
 6686   
             }
 6687   
 
 6688   
 
 6689  8 
             retval.tree = root_0;
 6690   
 
 6691   
             }
 6692   
 
 6693  8 
             retval.stop = input.LT(-1);
 6694   
 
 6695   
 
 6696  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6697  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6698   
 
 6699   
         }
 6700  0 
         catch (RecognitionException re) {
 6701  0 
             reportError(re);
 6702  0 
             recover(input,re);
 6703  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6704   
 
 6705   
         }
 6706   
 
 6707  0 
         finally {
 6708   
                 // do for sure before leaving
 6709  8 
         }
 6710  8 
         return retval;
 6711   
     }
 6712   
     // $ANTLR end "insert"
 6713   
 
 6714   
 
 6715  24 
     public static class delete_return extends ParserRuleReturnScope {
 6716   
         Object tree;
 6717  24 
         public Object getTree() { return tree; }
 6718   
     };
 6719   
 
 6720   
 
 6721   
     // $ANTLR start "delete"
 6722   
     // com\\googlecode\\sparkleg\\Sparql.g:224:1: delete : ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) );
 6723   
     public final SparqlParser.delete_return delete() throws RecognitionException {
 6724  24 
         SparqlParser.delete_return retval = new SparqlParser.delete_return();
 6725  24 
         retval.start = input.LT(1);
 6726   
 
 6727   
 
 6728  24 
         Object root_0 = null;
 6729   
 
 6730  24 
         Token DELETE146=null;
 6731  24 
         Token DELETE148=null;
 6732  24 
         SparqlParser.deleteData_return deleteData147 =null;
 6733   
 
 6734  24 
         SparqlParser.deleteWhere_return deleteWhere149 =null;
 6735   
 
 6736   
 
 6737  24 
         Object DELETE146_tree=null;
 6738  24 
         Object DELETE148_tree=null;
 6739  24 
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 6740  24 
         RewriteRuleSubtreeStream stream_deleteData=new RewriteRuleSubtreeStream(adaptor,"rule deleteData");
 6741  24 
         RewriteRuleSubtreeStream stream_deleteWhere=new RewriteRuleSubtreeStream(adaptor,"rule deleteWhere");
 6742   
         try {
 6743   
             // com\\googlecode\\sparkleg\\Sparql.g:225:5: ( DELETE deleteData -> ^( DELETE deleteData ) | DELETE deleteWhere -> ^( DELETE deleteWhere ) )
 6744  24 
             int alt49=2;
 6745  24 
             switch ( input.LA(1) ) {
 6746   
             case DELETE:
 6747   
                 {
 6748  24 
                 switch ( input.LA(2) ) {
 6749   
                 case DATA:
 6750   
                     {
 6751  12 
                     alt49=1;
 6752   
                     }
 6753  12 
                     break;
 6754   
                 case WHERE:
 6755   
                     {
 6756  12 
                     alt49=2;
 6757   
                     }
 6758  12 
                     break;
 6759   
                 default:
 6760  0 
                     NoViableAltException nvae =
 6761   
                         new NoViableAltException("", 49, 1, input);
 6762   
 
 6763  0 
                     throw nvae;
 6764   
 
 6765   
                 }
 6766   
 
 6767   
                 }
 6768  24 
                 break;
 6769   
             default:
 6770  0 
                 NoViableAltException nvae =
 6771   
                     new NoViableAltException("", 49, 0, input);
 6772   
 
 6773  0 
                 throw nvae;
 6774   
 
 6775   
             }
 6776   
 
 6777  24 
             switch (alt49) {
 6778   
                 case 1 :
 6779   
                     // com\\googlecode\\sparkleg\\Sparql.g:225:7: DELETE deleteData
 6780   
                     {
 6781  12 
                     DELETE146=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1770);
 6782  12 
                     stream_DELETE.add(DELETE146);
 6783   
 
 6784   
 
 6785  12 
                     pushFollow(FOLLOW_deleteData_in_delete1772);
 6786  12 
                     deleteData147=deleteData();
 6787   
 
 6788  12 
                     state._fsp--;
 6789   
 
 6790  12 
                     stream_deleteData.add(deleteData147.getTree());
 6791   
 
 6792   
                     // AST REWRITE
 6793   
                     // elements: DELETE, deleteData
 6794   
                     // token labels:
 6795   
                     // rule labels: retval
 6796   
                     // token list labels:
 6797   
                     // rule list labels:
 6798   
                     // wildcard labels:
 6799  12 
                     retval.tree = root_0;
 6800  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6801   
 
 6802  12 
                     root_0 = (Object)adaptor.nil();
 6803   
                     // 225:25: -> ^( DELETE deleteData )
 6804   
                     {
 6805   
                         // com\\googlecode\\sparkleg\\Sparql.g:225:28: ^( DELETE deleteData )
 6806   
                         {
 6807  12 
                         Object root_1 = (Object)adaptor.nil();
 6808  12 
                         root_1 = (Object)adaptor.becomeRoot(
 6809   
                         stream_DELETE.nextNode()
 6810   
                         , root_1);
 6811   
 
 6812  12 
                         adaptor.addChild(root_1, stream_deleteData.nextTree());
 6813   
 
 6814  12 
                         adaptor.addChild(root_0, root_1);
 6815   
                         }
 6816   
 
 6817   
                     }
 6818   
 
 6819   
 
 6820  12 
                     retval.tree = root_0;
 6821   
 
 6822   
                     }
 6823  12 
                     break;
 6824   
                 case 2 :
 6825   
                     // com\\googlecode\\sparkleg\\Sparql.g:226:7: DELETE deleteWhere
 6826   
                     {
 6827  12 
                     DELETE148=(Token)match(input,DELETE,FOLLOW_DELETE_in_delete1788);
 6828  12 
                     stream_DELETE.add(DELETE148);
 6829   
 
 6830   
 
 6831  12 
                     pushFollow(FOLLOW_deleteWhere_in_delete1790);
 6832  12 
                     deleteWhere149=deleteWhere();
 6833   
 
 6834  12 
                     state._fsp--;
 6835   
 
 6836  12 
                     stream_deleteWhere.add(deleteWhere149.getTree());
 6837   
 
 6838   
                     // AST REWRITE
 6839   
                     // elements: deleteWhere, DELETE
 6840   
                     // token labels:
 6841   
                     // rule labels: retval
 6842   
                     // token list labels:
 6843   
                     // rule list labels:
 6844   
                     // wildcard labels:
 6845  12 
                     retval.tree = root_0;
 6846  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6847   
 
 6848  12 
                     root_0 = (Object)adaptor.nil();
 6849   
                     // 226:26: -> ^( DELETE deleteWhere )
 6850   
                     {
 6851   
                         // com\\googlecode\\sparkleg\\Sparql.g:226:29: ^( DELETE deleteWhere )
 6852   
                         {
 6853  12 
                         Object root_1 = (Object)adaptor.nil();
 6854  12 
                         root_1 = (Object)adaptor.becomeRoot(
 6855   
                         stream_DELETE.nextNode()
 6856   
                         , root_1);
 6857   
 
 6858  12 
                         adaptor.addChild(root_1, stream_deleteWhere.nextTree());
 6859   
 
 6860  12 
                         adaptor.addChild(root_0, root_1);
 6861   
                         }
 6862   
 
 6863   
                     }
 6864   
 
 6865   
 
 6866  12 
                     retval.tree = root_0;
 6867   
 
 6868   
                     }
 6869   
                     break;
 6870   
 
 6871   
             }
 6872  24 
             retval.stop = input.LT(-1);
 6873   
 
 6874   
 
 6875  24 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6876  24 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6877   
 
 6878   
         }
 6879  0 
         catch (RecognitionException re) {
 6880  0 
             reportError(re);
 6881  0 
             recover(input,re);
 6882  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6883   
 
 6884   
         }
 6885   
 
 6886  0 
         finally {
 6887   
                 // do for sure before leaving
 6888  24 
         }
 6889  24 
         return retval;
 6890   
     }
 6891   
     // $ANTLR end "delete"
 6892   
 
 6893   
 
 6894  12 
     public static class deleteData_return extends ParserRuleReturnScope {
 6895   
         Object tree;
 6896  12 
         public Object getTree() { return tree; }
 6897   
     };
 6898   
 
 6899   
 
 6900   
     // $ANTLR start "deleteData"
 6901   
     // com\\googlecode\\sparkleg\\Sparql.g:229:1: deleteData : DATA quadPattern -> ^( DELETE DATA quadPattern ) ;
 6902   
     public final SparqlParser.deleteData_return deleteData() throws RecognitionException {
 6903  12 
         SparqlParser.deleteData_return retval = new SparqlParser.deleteData_return();
 6904  12 
         retval.start = input.LT(1);
 6905   
 
 6906   
 
 6907  12 
         Object root_0 = null;
 6908   
 
 6909  12 
         Token DATA150=null;
 6910  12 
         SparqlParser.quadPattern_return quadPattern151 =null;
 6911   
 
 6912   
 
 6913  12 
         Object DATA150_tree=null;
 6914  12 
         RewriteRuleTokenStream stream_DATA=new RewriteRuleTokenStream(adaptor,"token DATA");
 6915  12 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 6916   
         try {
 6917   
             // com\\googlecode\\sparkleg\\Sparql.g:230:5: ( DATA quadPattern -> ^( DELETE DATA quadPattern ) )
 6918   
             // com\\googlecode\\sparkleg\\Sparql.g:230:7: DATA quadPattern
 6919   
             {
 6920  12 
             DATA150=(Token)match(input,DATA,FOLLOW_DATA_in_deleteData1815);
 6921  12 
             stream_DATA.add(DATA150);
 6922   
 
 6923   
 
 6924  12 
             pushFollow(FOLLOW_quadPattern_in_deleteData1817);
 6925  12 
             quadPattern151=quadPattern();
 6926   
 
 6927  12 
             state._fsp--;
 6928   
 
 6929  12 
             stream_quadPattern.add(quadPattern151.getTree());
 6930   
 
 6931   
             // AST REWRITE
 6932   
             // elements: DATA, quadPattern
 6933   
             // token labels:
 6934   
             // rule labels: retval
 6935   
             // token list labels:
 6936   
             // rule list labels:
 6937   
             // wildcard labels:
 6938  12 
             retval.tree = root_0;
 6939  12 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 6940   
 
 6941  12 
             root_0 = (Object)adaptor.nil();
 6942   
             // 230:24: -> ^( DELETE DATA quadPattern )
 6943   
             {
 6944   
                 // com\\googlecode\\sparkleg\\Sparql.g:230:27: ^( DELETE DATA quadPattern )
 6945   
                 {
 6946  12 
                 Object root_1 = (Object)adaptor.nil();
 6947  12 
                 root_1 = (Object)adaptor.becomeRoot(
 6948   
                 (Object)adaptor.create(DELETE, "DELETE")
 6949   
                 , root_1);
 6950   
 
 6951  12 
                 adaptor.addChild(root_1,
 6952   
                 stream_DATA.nextNode()
 6953   
                 );
 6954   
 
 6955  12 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 6956   
 
 6957  12 
                 adaptor.addChild(root_0, root_1);
 6958   
                 }
 6959   
 
 6960   
             }
 6961   
 
 6962   
 
 6963  12 
             retval.tree = root_0;
 6964   
 
 6965   
             }
 6966   
 
 6967  12 
             retval.stop = input.LT(-1);
 6968   
 
 6969   
 
 6970  12 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 6971  12 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 6972   
 
 6973   
         }
 6974  0 
         catch (RecognitionException re) {
 6975  0 
             reportError(re);
 6976  0 
             recover(input,re);
 6977  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 6978   
 
 6979   
         }
 6980   
 
 6981  0 
         finally {
 6982   
                 // do for sure before leaving
 6983  12 
         }
 6984  12 
         return retval;
 6985   
     }
 6986   
     // $ANTLR end "deleteData"
 6987   
 
 6988   
 
 6989  12 
     public static class deleteWhere_return extends ParserRuleReturnScope {
 6990   
         Object tree;
 6991  12 
         public Object getTree() { return tree; }
 6992   
     };
 6993   
 
 6994   
 
 6995   
     // $ANTLR start "deleteWhere"
 6996   
     // com\\googlecode\\sparkleg\\Sparql.g:233:1: deleteWhere : WHERE quadPattern -> ^( DELETE WHERE quadPattern ) ;
 6997   
     public final SparqlParser.deleteWhere_return deleteWhere() throws RecognitionException {
 6998  12 
         SparqlParser.deleteWhere_return retval = new SparqlParser.deleteWhere_return();
 6999  12 
         retval.start = input.LT(1);
 7000   
 
 7001   
 
 7002  12 
         Object root_0 = null;
 7003   
 
 7004  12 
         Token WHERE152=null;
 7005  12 
         SparqlParser.quadPattern_return quadPattern153 =null;
 7006   
 
 7007   
 
 7008  12 
         Object WHERE152_tree=null;
 7009  12 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7010  12 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7011   
         try {
 7012   
             // com\\googlecode\\sparkleg\\Sparql.g:234:5: ( WHERE quadPattern -> ^( DELETE WHERE quadPattern ) )
 7013   
             // com\\googlecode\\sparkleg\\Sparql.g:234:7: WHERE quadPattern
 7014   
             {
 7015  12 
             WHERE152=(Token)match(input,WHERE,FOLLOW_WHERE_in_deleteWhere1844);
 7016  12 
             stream_WHERE.add(WHERE152);
 7017   
 
 7018   
 
 7019  12 
             pushFollow(FOLLOW_quadPattern_in_deleteWhere1846);
 7020  12 
             quadPattern153=quadPattern();
 7021   
 
 7022  12 
             state._fsp--;
 7023   
 
 7024  12 
             stream_quadPattern.add(quadPattern153.getTree());
 7025   
 
 7026   
             // AST REWRITE
 7027   
             // elements: quadPattern, WHERE
 7028   
             // token labels:
 7029   
             // rule labels: retval
 7030   
             // token list labels:
 7031   
             // rule list labels:
 7032   
             // wildcard labels:
 7033  12 
             retval.tree = root_0;
 7034  12 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7035   
 
 7036  12 
             root_0 = (Object)adaptor.nil();
 7037   
             // 234:25: -> ^( DELETE WHERE quadPattern )
 7038   
             {
 7039   
                 // com\\googlecode\\sparkleg\\Sparql.g:234:28: ^( DELETE WHERE quadPattern )
 7040   
                 {
 7041  12 
                 Object root_1 = (Object)adaptor.nil();
 7042  12 
                 root_1 = (Object)adaptor.becomeRoot(
 7043   
                 (Object)adaptor.create(DELETE, "DELETE")
 7044   
                 , root_1);
 7045   
 
 7046  12 
                 adaptor.addChild(root_1,
 7047   
                 stream_WHERE.nextNode()
 7048   
                 );
 7049   
 
 7050  12 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7051   
 
 7052  12 
                 adaptor.addChild(root_0, root_1);
 7053   
                 }
 7054   
 
 7055   
             }
 7056   
 
 7057   
 
 7058  12 
             retval.tree = root_0;
 7059   
 
 7060   
             }
 7061   
 
 7062  12 
             retval.stop = input.LT(-1);
 7063   
 
 7064   
 
 7065  12 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7066  12 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7067   
 
 7068   
         }
 7069  0 
         catch (RecognitionException re) {
 7070  0 
             reportError(re);
 7071  0 
             recover(input,re);
 7072  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7073   
 
 7074   
         }
 7075   
 
 7076  0 
         finally {
 7077   
                 // do for sure before leaving
 7078  12 
         }
 7079  12 
         return retval;
 7080   
     }
 7081   
     // $ANTLR end "deleteWhere"
 7082   
 
 7083   
 
 7084  80 
     public static class modify_return extends ParserRuleReturnScope {
 7085   
         Object tree;
 7086  80 
         public Object getTree() { return tree; }
 7087   
     };
 7088   
 
 7089   
 
 7090   
     // $ANTLR start "modify"
 7091   
     // com\\googlecode\\sparkleg\\Sparql.g:237:1: modify : ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) ;
 7092   
     public final SparqlParser.modify_return modify() throws RecognitionException {
 7093  80 
         SparqlParser.modify_return retval = new SparqlParser.modify_return();
 7094  80 
         retval.start = input.LT(1);
 7095   
 
 7096   
 
 7097  80 
         Object root_0 = null;
 7098   
 
 7099  80 
         Token WITH154=null;
 7100  80 
         Token WHERE160=null;
 7101  80 
         SparqlParser.iriRef_return iriRef155 =null;
 7102   
 
 7103  80 
         SparqlParser.deleteClause_return deleteClause156 =null;
 7104   
 
 7105  80 
         SparqlParser.insertClause_return insertClause157 =null;
 7106   
 
 7107  80 
         SparqlParser.insertClause_return insertClause158 =null;
 7108   
 
 7109  80 
         SparqlParser.usingClause_return usingClause159 =null;
 7110   
 
 7111  80 
         SparqlParser.groupGraphPattern_return groupGraphPattern161 =null;
 7112   
 
 7113   
 
 7114  80 
         Object WITH154_tree=null;
 7115  80 
         Object WHERE160_tree=null;
 7116  80 
         RewriteRuleTokenStream stream_WHERE=new RewriteRuleTokenStream(adaptor,"token WHERE");
 7117  80 
         RewriteRuleTokenStream stream_WITH=new RewriteRuleTokenStream(adaptor,"token WITH");
 7118  80 
         RewriteRuleSubtreeStream stream_deleteClause=new RewriteRuleSubtreeStream(adaptor,"rule deleteClause");
 7119  80 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 7120  80 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7121  80 
         RewriteRuleSubtreeStream stream_insertClause=new RewriteRuleSubtreeStream(adaptor,"rule insertClause");
 7122  80 
         RewriteRuleSubtreeStream stream_usingClause=new RewriteRuleSubtreeStream(adaptor,"rule usingClause");
 7123   
         try {
 7124   
             // com\\googlecode\\sparkleg\\Sparql.g:238:5: ( ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) ) )
 7125   
             // com\\googlecode\\sparkleg\\Sparql.g:238:7: ( WITH iriRef )? ( deleteClause ( insertClause )? | insertClause ) ( usingClause )* WHERE groupGraphPattern
 7126   
             {
 7127   
             // com\\googlecode\\sparkleg\\Sparql.g:238:7: ( WITH iriRef )?
 7128  80 
             int alt50=2;
 7129  80 
             switch ( input.LA(1) ) {
 7130   
                 case WITH:
 7131   
                     {
 7132  14 
                     alt50=1;
 7133   
                     }
 7134   
                     break;
 7135   
             }
 7136   
 
 7137  80 
             switch (alt50) {
 7138   
                 case 1 :
 7139   
                     // com\\googlecode\\sparkleg\\Sparql.g:238:8: WITH iriRef
 7140   
                     {
 7141  14 
                     WITH154=(Token)match(input,WITH,FOLLOW_WITH_in_modify1878);
 7142  14 
                     stream_WITH.add(WITH154);
 7143   
 
 7144   
 
 7145  14 
                     pushFollow(FOLLOW_iriRef_in_modify1880);
 7146  14 
                     iriRef155=iriRef();
 7147   
 
 7148  14 
                     state._fsp--;
 7149   
 
 7150  14 
                     stream_iriRef.add(iriRef155.getTree());
 7151   
 
 7152   
                     }
 7153   
                     break;
 7154   
 
 7155   
             }
 7156   
 
 7157   
 
 7158   
             // com\\googlecode\\sparkleg\\Sparql.g:238:22: ( deleteClause ( insertClause )? | insertClause )
 7159  80 
             int alt52=2;
 7160  80 
             switch ( input.LA(1) ) {
 7161   
             case DELETE:
 7162   
                 {
 7163  66 
                 alt52=1;
 7164   
                 }
 7165  66 
                 break;
 7166   
             case INSERT:
 7167   
                 {
 7168  14 
                 alt52=2;
 7169   
                 }
 7170  14 
                 break;
 7171   
             default:
 7172  0 
                 NoViableAltException nvae =
 7173   
                     new NoViableAltException("", 52, 0, input);
 7174   
 
 7175  0 
                 throw nvae;
 7176   
 
 7177   
             }
 7178   
 
 7179  80 
             switch (alt52) {
 7180   
                 case 1 :
 7181   
                     // com\\googlecode\\sparkleg\\Sparql.g:238:23: deleteClause ( insertClause )?
 7182   
                     {
 7183  66 
                     pushFollow(FOLLOW_deleteClause_in_modify1885);
 7184  66 
                     deleteClause156=deleteClause();
 7185   
 
 7186  66 
                     state._fsp--;
 7187   
 
 7188  66 
                     stream_deleteClause.add(deleteClause156.getTree());
 7189   
 
 7190   
                     // com\\googlecode\\sparkleg\\Sparql.g:238:36: ( insertClause )?
 7191  66 
                     int alt51=2;
 7192  66 
                     switch ( input.LA(1) ) {
 7193   
                         case INSERT:
 7194   
                             {
 7195  10 
                             alt51=1;
 7196   
                             }
 7197   
                             break;
 7198   
                     }
 7199   
 
 7200  66 
                     switch (alt51) {
 7201   
                         case 1 :
 7202   
                             // com\\googlecode\\sparkleg\\Sparql.g:238:36: insertClause
 7203   
                             {
 7204  10 
                             pushFollow(FOLLOW_insertClause_in_modify1887);
 7205  10 
                             insertClause157=insertClause();
 7206   
 
 7207  10 
                             state._fsp--;
 7208   
 
 7209  10 
                             stream_insertClause.add(insertClause157.getTree());
 7210   
 
 7211   
                             }
 7212   
                             break;
 7213   
 
 7214   
                     }
 7215   
 
 7216   
 
 7217   
                     }
 7218  66 
                     break;
 7219   
                 case 2 :
 7220   
                     // com\\googlecode\\sparkleg\\Sparql.g:238:52: insertClause
 7221   
                     {
 7222  14 
                     pushFollow(FOLLOW_insertClause_in_modify1892);
 7223  14 
                     insertClause158=insertClause();
 7224   
 
 7225  14 
                     state._fsp--;
 7226   
 
 7227  14 
                     stream_insertClause.add(insertClause158.getTree());
 7228   
 
 7229   
                     }
 7230   
                     break;
 7231   
 
 7232   
             }
 7233   
 
 7234   
 
 7235   
             // com\\googlecode\\sparkleg\\Sparql.g:238:66: ( usingClause )*
 7236   
             loop53:
 7237   
             do {
 7238  95 
                 int alt53=2;
 7239  95 
                 switch ( input.LA(1) ) {
 7240   
                 case USING:
 7241   
                     {
 7242  15 
                     alt53=1;
 7243   
                     }
 7244   
                     break;
 7245   
 
 7246   
                 }
 7247   
 
 7248  95 
                 switch (alt53) {
 7249   
                     case 1 :
 7250   
                         // com\\googlecode\\sparkleg\\Sparql.g:238:66: usingClause
 7251   
                         {
 7252  15 
                         pushFollow(FOLLOW_usingClause_in_modify1895);
 7253  15 
                         usingClause159=usingClause();
 7254   
 
 7255  15 
                         state._fsp--;
 7256   
 
 7257  15 
                         stream_usingClause.add(usingClause159.getTree());
 7258   
 
 7259   
                         }
 7260  15 
                         break;
 7261   
 
 7262   
                     default :
 7263  80 
                         break loop53;
 7264   
                 }
 7265  15 
             } while (true);
 7266   
 
 7267   
 
 7268  80 
             WHERE160=(Token)match(input,WHERE,FOLLOW_WHERE_in_modify1898);
 7269  80 
             stream_WHERE.add(WHERE160);
 7270   
 
 7271   
 
 7272  80 
             pushFollow(FOLLOW_groupGraphPattern_in_modify1900);
 7273  80 
             groupGraphPattern161=groupGraphPattern();
 7274   
 
 7275  80 
             state._fsp--;
 7276   
 
 7277  80 
             stream_groupGraphPattern.add(groupGraphPattern161.getTree());
 7278   
 
 7279   
             // AST REWRITE
 7280   
             // elements: deleteClause, insertClause, usingClause, iriRef, WITH, groupGraphPattern
 7281   
             // token labels:
 7282   
             // rule labels: retval
 7283   
             // token list labels:
 7284   
             // rule list labels:
 7285   
             // wildcard labels:
 7286  80 
             retval.tree = root_0;
 7287  80 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7288   
 
 7289  80 
             root_0 = (Object)adaptor.nil();
 7290   
             // 238:103: -> ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7291   
             {
 7292   
                 // com\\googlecode\\sparkleg\\Sparql.g:238:106: ^( MODIFY ( WITH iriRef )? ( deleteClause )* ( insertClause )* ( usingClause )* ^( WHERE_CLAUSE groupGraphPattern ) )
 7293   
                 {
 7294  80 
                 Object root_1 = (Object)adaptor.nil();
 7295  80 
                 root_1 = (Object)adaptor.becomeRoot(
 7296   
                 (Object)adaptor.create(MODIFY, "MODIFY")
 7297   
                 , root_1);
 7298   
 
 7299   
                 // com\\googlecode\\sparkleg\\Sparql.g:238:115: ( WITH iriRef )?
 7300  80 
                 if ( stream_iriRef.hasNext()||stream_WITH.hasNext() ) {
 7301  14 
                     adaptor.addChild(root_1,
 7302   
                     stream_WITH.nextNode()
 7303   
                     );
 7304   
 
 7305  14 
                     adaptor.addChild(root_1, stream_iriRef.nextTree());
 7306   
 
 7307   
                 }
 7308  80 
                 stream_iriRef.reset();
 7309  80 
                 stream_WITH.reset();
 7310   
 
 7311   
                 // com\\googlecode\\sparkleg\\Sparql.g:238:130: ( deleteClause )*
 7312  146 
                 while ( stream_deleteClause.hasNext() ) {
 7313  66 
                     adaptor.addChild(root_1, stream_deleteClause.nextTree());
 7314   
 
 7315   
                 }
 7316  80 
                 stream_deleteClause.reset();
 7317   
 
 7318   
                 // com\\googlecode\\sparkleg\\Sparql.g:238:144: ( insertClause )*
 7319  104 
                 while ( stream_insertClause.hasNext() ) {
 7320  24 
                     adaptor.addChild(root_1, stream_insertClause.nextTree());
 7321   
 
 7322   
                 }
 7323  80 
                 stream_insertClause.reset();
 7324   
 
 7325   
                 // com\\googlecode\\sparkleg\\Sparql.g:238:158: ( usingClause )*
 7326  95 
                 while ( stream_usingClause.hasNext() ) {
 7327  15 
                     adaptor.addChild(root_1, stream_usingClause.nextTree());
 7328   
 
 7329   
                 }
 7330  80 
                 stream_usingClause.reset();
 7331   
 
 7332   
                 // com\\googlecode\\sparkleg\\Sparql.g:238:171: ^( WHERE_CLAUSE groupGraphPattern )
 7333   
                 {
 7334  80 
                 Object root_2 = (Object)adaptor.nil();
 7335  80 
                 root_2 = (Object)adaptor.becomeRoot(
 7336   
                 (Object)adaptor.create(WHERE_CLAUSE, "WHERE_CLAUSE")
 7337   
                 , root_2);
 7338   
 
 7339  80 
                 adaptor.addChild(root_2, stream_groupGraphPattern.nextTree());
 7340   
 
 7341  80 
                 adaptor.addChild(root_1, root_2);
 7342   
                 }
 7343   
 
 7344  80 
                 adaptor.addChild(root_0, root_1);
 7345   
                 }
 7346   
 
 7347   
             }
 7348   
 
 7349   
 
 7350  80 
             retval.tree = root_0;
 7351   
 
 7352   
             }
 7353   
 
 7354  80 
             retval.stop = input.LT(-1);
 7355   
 
 7356   
 
 7357  80 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7358  80 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7359   
 
 7360   
         }
 7361  0 
         catch (RecognitionException re) {
 7362  0 
             reportError(re);
 7363  0 
             recover(input,re);
 7364  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7365   
 
 7366   
         }
 7367   
 
 7368  0 
         finally {
 7369   
                 // do for sure before leaving
 7370  80 
         }
 7371  80 
         return retval;
 7372   
     }
 7373   
     // $ANTLR end "modify"
 7374   
 
 7375   
 
 7376  66 
     public static class deleteClause_return extends ParserRuleReturnScope {
 7377   
         Object tree;
 7378  66 
         public Object getTree() { return tree; }
 7379   
     };
 7380   
 
 7381   
 
 7382   
     // $ANTLR start "deleteClause"
 7383   
     // com\\googlecode\\sparkleg\\Sparql.g:241:1: deleteClause : DELETE quadPattern -> ^( DELETE quadPattern ) ;
 7384   
     public final SparqlParser.deleteClause_return deleteClause() throws RecognitionException {
 7385  66 
         SparqlParser.deleteClause_return retval = new SparqlParser.deleteClause_return();
 7386  66 
         retval.start = input.LT(1);
 7387   
 
 7388   
 
 7389  66 
         Object root_0 = null;
 7390   
 
 7391  66 
         Token DELETE162=null;
 7392  66 
         SparqlParser.quadPattern_return quadPattern163 =null;
 7393   
 
 7394   
 
 7395  66 
         Object DELETE162_tree=null;
 7396  66 
         RewriteRuleTokenStream stream_DELETE=new RewriteRuleTokenStream(adaptor,"token DELETE");
 7397  66 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7398   
         try {
 7399   
             // com\\googlecode\\sparkleg\\Sparql.g:242:5: ( DELETE quadPattern -> ^( DELETE quadPattern ) )
 7400   
             // com\\googlecode\\sparkleg\\Sparql.g:242:7: DELETE quadPattern
 7401   
             {
 7402  66 
             DELETE162=(Token)match(input,DELETE,FOLLOW_DELETE_in_deleteClause1947);
 7403  66 
             stream_DELETE.add(DELETE162);
 7404   
 
 7405   
 
 7406  66 
             pushFollow(FOLLOW_quadPattern_in_deleteClause1949);
 7407  66 
             quadPattern163=quadPattern();
 7408   
 
 7409  66 
             state._fsp--;
 7410   
 
 7411  66 
             stream_quadPattern.add(quadPattern163.getTree());
 7412   
 
 7413   
             // AST REWRITE
 7414   
             // elements: quadPattern, DELETE
 7415   
             // token labels:
 7416   
             // rule labels: retval
 7417   
             // token list labels:
 7418   
             // rule list labels:
 7419   
             // wildcard labels:
 7420  66 
             retval.tree = root_0;
 7421  66 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7422   
 
 7423  66 
             root_0 = (Object)adaptor.nil();
 7424   
             // 242:26: -> ^( DELETE quadPattern )
 7425   
             {
 7426   
                 // com\\googlecode\\sparkleg\\Sparql.g:242:29: ^( DELETE quadPattern )
 7427   
                 {
 7428  66 
                 Object root_1 = (Object)adaptor.nil();
 7429  66 
                 root_1 = (Object)adaptor.becomeRoot(
 7430   
                 stream_DELETE.nextNode()
 7431   
                 , root_1);
 7432   
 
 7433  66 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7434   
 
 7435  66 
                 adaptor.addChild(root_0, root_1);
 7436   
                 }
 7437   
 
 7438   
             }
 7439   
 
 7440   
 
 7441  66 
             retval.tree = root_0;
 7442   
 
 7443   
             }
 7444   
 
 7445  66 
             retval.stop = input.LT(-1);
 7446   
 
 7447   
 
 7448  66 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7449  66 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7450   
 
 7451   
         }
 7452  0 
         catch (RecognitionException re) {
 7453  0 
             reportError(re);
 7454  0 
             recover(input,re);
 7455  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7456   
 
 7457   
         }
 7458   
 
 7459  0 
         finally {
 7460   
                 // do for sure before leaving
 7461  66 
         }
 7462  66 
         return retval;
 7463   
     }
 7464   
     // $ANTLR end "deleteClause"
 7465   
 
 7466   
 
 7467  24 
     public static class insertClause_return extends ParserRuleReturnScope {
 7468   
         Object tree;
 7469  24 
         public Object getTree() { return tree; }
 7470   
     };
 7471   
 
 7472   
 
 7473   
     // $ANTLR start "insertClause"
 7474   
     // com\\googlecode\\sparkleg\\Sparql.g:245:1: insertClause : INSERT quadPattern -> ^( INSERT quadPattern ) ;
 7475   
     public final SparqlParser.insertClause_return insertClause() throws RecognitionException {
 7476  24 
         SparqlParser.insertClause_return retval = new SparqlParser.insertClause_return();
 7477  24 
         retval.start = input.LT(1);
 7478   
 
 7479   
 
 7480  24 
         Object root_0 = null;
 7481   
 
 7482  24 
         Token INSERT164=null;
 7483  24 
         SparqlParser.quadPattern_return quadPattern165 =null;
 7484   
 
 7485   
 
 7486  24 
         Object INSERT164_tree=null;
 7487  24 
         RewriteRuleTokenStream stream_INSERT=new RewriteRuleTokenStream(adaptor,"token INSERT");
 7488  24 
         RewriteRuleSubtreeStream stream_quadPattern=new RewriteRuleSubtreeStream(adaptor,"rule quadPattern");
 7489   
         try {
 7490   
             // com\\googlecode\\sparkleg\\Sparql.g:246:5: ( INSERT quadPattern -> ^( INSERT quadPattern ) )
 7491   
             // com\\googlecode\\sparkleg\\Sparql.g:246:7: INSERT quadPattern
 7492   
             {
 7493  24 
             INSERT164=(Token)match(input,INSERT,FOLLOW_INSERT_in_insertClause1980);
 7494  24 
             stream_INSERT.add(INSERT164);
 7495   
 
 7496   
 
 7497  24 
             pushFollow(FOLLOW_quadPattern_in_insertClause1982);
 7498  24 
             quadPattern165=quadPattern();
 7499   
 
 7500  24 
             state._fsp--;
 7501   
 
 7502  24 
             stream_quadPattern.add(quadPattern165.getTree());
 7503   
 
 7504   
             // AST REWRITE
 7505   
             // elements: quadPattern, INSERT
 7506   
             // token labels:
 7507   
             // rule labels: retval
 7508   
             // token list labels:
 7509   
             // rule list labels:
 7510   
             // wildcard labels:
 7511  24 
             retval.tree = root_0;
 7512  24 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7513   
 
 7514  24 
             root_0 = (Object)adaptor.nil();
 7515   
             // 246:26: -> ^( INSERT quadPattern )
 7516   
             {
 7517   
                 // com\\googlecode\\sparkleg\\Sparql.g:246:29: ^( INSERT quadPattern )
 7518   
                 {
 7519  24 
                 Object root_1 = (Object)adaptor.nil();
 7520  24 
                 root_1 = (Object)adaptor.becomeRoot(
 7521   
                 stream_INSERT.nextNode()
 7522   
                 , root_1);
 7523   
 
 7524  24 
                 adaptor.addChild(root_1, stream_quadPattern.nextTree());
 7525   
 
 7526  24 
                 adaptor.addChild(root_0, root_1);
 7527   
                 }
 7528   
 
 7529   
             }
 7530   
 
 7531   
 
 7532  24 
             retval.tree = root_0;
 7533   
 
 7534   
             }
 7535   
 
 7536  24 
             retval.stop = input.LT(-1);
 7537   
 
 7538   
 
 7539  24 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7540  24 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7541   
 
 7542   
         }
 7543  0 
         catch (RecognitionException re) {
 7544  0 
             reportError(re);
 7545  0 
             recover(input,re);
 7546  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7547   
 
 7548   
         }
 7549   
 
 7550  0 
         finally {
 7551   
                 // do for sure before leaving
 7552  24 
         }
 7553  24 
         return retval;
 7554   
     }
 7555   
     // $ANTLR end "insertClause"
 7556   
 
 7557   
 
 7558  15 
     public static class usingClause_return extends ParserRuleReturnScope {
 7559   
         Object tree;
 7560  15 
         public Object getTree() { return tree; }
 7561   
     };
 7562   
 
 7563   
 
 7564   
     // $ANTLR start "usingClause"
 7565   
     // com\\googlecode\\sparkleg\\Sparql.g:249:1: usingClause : USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) ;
 7566   
     public final SparqlParser.usingClause_return usingClause() throws RecognitionException {
 7567  15 
         SparqlParser.usingClause_return retval = new SparqlParser.usingClause_return();
 7568  15 
         retval.start = input.LT(1);
 7569   
 
 7570   
 
 7571  15 
         Object root_0 = null;
 7572   
 
 7573  15 
         Token USING166=null;
 7574  15 
         Token NAMED167=null;
 7575  15 
         SparqlParser.iriRef_return iriRef168 =null;
 7576   
 
 7577   
 
 7578  15 
         Object USING166_tree=null;
 7579  15 
         Object NAMED167_tree=null;
 7580  15 
         RewriteRuleTokenStream stream_USING=new RewriteRuleTokenStream(adaptor,"token USING");
 7581  15 
         RewriteRuleTokenStream stream_NAMED=new RewriteRuleTokenStream(adaptor,"token NAMED");
 7582  15 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 7583   
         try {
 7584   
             // com\\googlecode\\sparkleg\\Sparql.g:250:5: ( USING ( NAMED )? iriRef -> ^( USING ( NAMED )? iriRef ) )
 7585   
             // com\\googlecode\\sparkleg\\Sparql.g:250:7: USING ( NAMED )? iriRef
 7586   
             {
 7587  15 
             USING166=(Token)match(input,USING,FOLLOW_USING_in_usingClause2007);
 7588  15 
             stream_USING.add(USING166);
 7589   
 
 7590   
 
 7591   
             // com\\googlecode\\sparkleg\\Sparql.g:250:13: ( NAMED )?
 7592  15 
             int alt54=2;
 7593  15 
             switch ( input.LA(1) ) {
 7594   
                 case NAMED:
 7595   
                     {
 7596  0 
                     alt54=1;
 7597   
                     }
 7598   
                     break;
 7599   
             }
 7600   
 
 7601  15 
             switch (alt54) {
 7602   
                 case 1 :
 7603   
                     // com\\googlecode\\sparkleg\\Sparql.g:250:13: NAMED
 7604   
                     {
 7605  0 
                     NAMED167=(Token)match(input,NAMED,FOLLOW_NAMED_in_usingClause2009);
 7606  0 
                     stream_NAMED.add(NAMED167);
 7607   
 
 7608   
 
 7609   
                     }
 7610   
                     break;
 7611   
 
 7612   
             }
 7613   
 
 7614   
 
 7615  15 
             pushFollow(FOLLOW_iriRef_in_usingClause2012);
 7616  15 
             iriRef168=iriRef();
 7617   
 
 7618  15 
             state._fsp--;
 7619   
 
 7620  15 
             stream_iriRef.add(iriRef168.getTree());
 7621   
 
 7622   
             // AST REWRITE
 7623   
             // elements: iriRef, USING, NAMED
 7624   
             // token labels:
 7625   
             // rule labels: retval
 7626   
             // token list labels:
 7627   
             // rule list labels:
 7628   
             // wildcard labels:
 7629  15 
             retval.tree = root_0;
 7630  15 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 7631   
 
 7632  15 
             root_0 = (Object)adaptor.nil();
 7633   
             // 250:27: -> ^( USING ( NAMED )? iriRef )
 7634   
             {
 7635   
                 // com\\googlecode\\sparkleg\\Sparql.g:250:30: ^( USING ( NAMED )? iriRef )
 7636   
                 {
 7637  15 
                 Object root_1 = (Object)adaptor.nil();
 7638  15 
                 root_1 = (Object)adaptor.becomeRoot(
 7639   
                 stream_USING.nextNode()
 7640   
                 , root_1);
 7641   
 
 7642   
                 // com\\googlecode\\sparkleg\\Sparql.g:250:38: ( NAMED )?
 7643  15 
                 if ( stream_NAMED.hasNext() ) {
 7644  0 
                     adaptor.addChild(root_1,
 7645   
                     stream_NAMED.nextNode()
 7646   
                     );
 7647   
 
 7648   
                 }
 7649  15 
                 stream_NAMED.reset();
 7650   
 
 7651  15 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 7652   
 
 7653  15 
                 adaptor.addChild(root_0, root_1);
 7654   
                 }
 7655   
 
 7656   
             }
 7657   
 
 7658   
 
 7659  15 
             retval.tree = root_0;
 7660   
 
 7661   
             }
 7662   
 
 7663  15 
             retval.stop = input.LT(-1);
 7664   
 
 7665   
 
 7666  15 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7667  15 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7668   
 
 7669   
         }
 7670  0 
         catch (RecognitionException re) {
 7671  0 
             reportError(re);
 7672  0 
             recover(input,re);
 7673  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7674   
 
 7675   
         }
 7676   
 
 7677  0 
         finally {
 7678   
                 // do for sure before leaving
 7679  15 
         }
 7680  15 
         return retval;
 7681   
     }
 7682   
     // $ANTLR end "usingClause"
 7683   
 
 7684   
 
 7685  0 
     public static class graphOrDefault_return extends ParserRuleReturnScope {
 7686   
         Object tree;
 7687  0 
         public Object getTree() { return tree; }
 7688   
     };
 7689   
 
 7690   
 
 7691   
     // $ANTLR start "graphOrDefault"
 7692   
     // com\\googlecode\\sparkleg\\Sparql.g:253:1: graphOrDefault : ( DEFAULT | ( GRAPH )? iriRef );
 7693   
     public final SparqlParser.graphOrDefault_return graphOrDefault() throws RecognitionException {
 7694  0 
         SparqlParser.graphOrDefault_return retval = new SparqlParser.graphOrDefault_return();
 7695  0 
         retval.start = input.LT(1);
 7696   
 
 7697   
 
 7698  0 
         Object root_0 = null;
 7699   
 
 7700  0 
         Token DEFAULT169=null;
 7701  0 
         Token GRAPH170=null;
 7702  0 
         SparqlParser.iriRef_return iriRef171 =null;
 7703   
 
 7704   
 
 7705  0 
         Object DEFAULT169_tree=null;
 7706  0 
         Object GRAPH170_tree=null;
 7707   
 
 7708   
         try {
 7709   
             // com\\googlecode\\sparkleg\\Sparql.g:254:5: ( DEFAULT | ( GRAPH )? iriRef )
 7710  0 
             int alt56=2;
 7711  0 
             switch ( input.LA(1) ) {
 7712   
             case DEFAULT:
 7713   
                 {
 7714  0 
                 alt56=1;
 7715   
                 }
 7716  0 
                 break;
 7717   
             case GRAPH:
 7718   
             case IRI_REF:
 7719   
             case PNAME_LN:
 7720   
             case PNAME_NS:
 7721   
                 {
 7722  0 
                 alt56=2;
 7723   
                 }
 7724  0 
                 break;
 7725   
             default:
 7726  0 
                 NoViableAltException nvae =
 7727   
                     new NoViableAltException("", 56, 0, input);
 7728   
 
 7729  0 
                 throw nvae;
 7730   
 
 7731   
             }
 7732   
 
 7733  0 
             switch (alt56) {
 7734   
                 case 1 :
 7735   
                     // com\\googlecode\\sparkleg\\Sparql.g:254:7: DEFAULT
 7736   
                     {
 7737  0 
                     root_0 = (Object)adaptor.nil();
 7738   
 
 7739   
 
 7740  0 
                     DEFAULT169=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphOrDefault2043);
 7741  0 
                     DEFAULT169_tree =
 7742   
                     (Object)adaptor.create(DEFAULT169)
 7743   
                     ;
 7744  0 
                     adaptor.addChild(root_0, DEFAULT169_tree);
 7745   
 
 7746   
 
 7747   
                     }
 7748  0 
                     break;
 7749   
                 case 2 :
 7750   
                     // com\\googlecode\\sparkleg\\Sparql.g:255:7: ( GRAPH )? iriRef
 7751   
                     {
 7752  0 
                     root_0 = (Object)adaptor.nil();
 7753   
 
 7754   
 
 7755   
                     // com\\googlecode\\sparkleg\\Sparql.g:255:7: ( GRAPH )?
 7756  0 
                     int alt55=2;
 7757  0 
                     switch ( input.LA(1) ) {
 7758   
                         case GRAPH:
 7759   
                             {
 7760  0 
                             alt55=1;
 7761   
                             }
 7762   
                             break;
 7763   
                     }
 7764   
 
 7765  0 
                     switch (alt55) {
 7766   
                         case 1 :
 7767   
                             // com\\googlecode\\sparkleg\\Sparql.g:255:7: GRAPH
 7768   
                             {
 7769  0 
                             GRAPH170=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphOrDefault2052);
 7770  0 
                             GRAPH170_tree =
 7771   
                             (Object)adaptor.create(GRAPH170)
 7772   
                             ;
 7773  0 
                             adaptor.addChild(root_0, GRAPH170_tree);
 7774   
 
 7775   
 
 7776   
                             }
 7777   
                             break;
 7778   
 
 7779   
                     }
 7780   
 
 7781   
 
 7782  0 
                     pushFollow(FOLLOW_iriRef_in_graphOrDefault2055);
 7783  0 
                     iriRef171=iriRef();
 7784   
 
 7785  0 
                     state._fsp--;
 7786   
 
 7787  0 
                     adaptor.addChild(root_0, iriRef171.getTree());
 7788   
 
 7789   
                     }
 7790   
                     break;
 7791   
 
 7792   
             }
 7793  0 
             retval.stop = input.LT(-1);
 7794   
 
 7795   
 
 7796  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7797  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7798   
 
 7799   
         }
 7800  0 
         catch (RecognitionException re) {
 7801  0 
             reportError(re);
 7802  0 
             recover(input,re);
 7803  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7804   
 
 7805   
         }
 7806   
 
 7807  0 
         finally {
 7808   
                 // do for sure before leaving
 7809  0 
         }
 7810  0 
         return retval;
 7811   
     }
 7812   
     // $ANTLR end "graphOrDefault"
 7813   
 
 7814   
 
 7815  4 
     public static class graphRef_return extends ParserRuleReturnScope {
 7816   
         Object tree;
 7817  4 
         public Object getTree() { return tree; }
 7818   
     };
 7819   
 
 7820   
 
 7821   
     // $ANTLR start "graphRef"
 7822   
     // com\\googlecode\\sparkleg\\Sparql.g:258:1: graphRef : GRAPH iriRef ;
 7823   
     public final SparqlParser.graphRef_return graphRef() throws RecognitionException {
 7824  4 
         SparqlParser.graphRef_return retval = new SparqlParser.graphRef_return();
 7825  4 
         retval.start = input.LT(1);
 7826   
 
 7827   
 
 7828  4 
         Object root_0 = null;
 7829   
 
 7830  4 
         Token GRAPH172=null;
 7831  4 
         SparqlParser.iriRef_return iriRef173 =null;
 7832   
 
 7833   
 
 7834  4 
         Object GRAPH172_tree=null;
 7835   
 
 7836   
         try {
 7837   
             // com\\googlecode\\sparkleg\\Sparql.g:259:5: ( GRAPH iriRef )
 7838   
             // com\\googlecode\\sparkleg\\Sparql.g:259:7: GRAPH iriRef
 7839   
             {
 7840  4 
             root_0 = (Object)adaptor.nil();
 7841   
 
 7842   
 
 7843  4 
             GRAPH172=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphRef2082);
 7844  4 
             GRAPH172_tree =
 7845   
             (Object)adaptor.create(GRAPH172)
 7846   
             ;
 7847  4 
             adaptor.addChild(root_0, GRAPH172_tree);
 7848   
 
 7849   
 
 7850  4 
             pushFollow(FOLLOW_iriRef_in_graphRef2084);
 7851  4 
             iriRef173=iriRef();
 7852   
 
 7853  4 
             state._fsp--;
 7854   
 
 7855  4 
             adaptor.addChild(root_0, iriRef173.getTree());
 7856   
 
 7857   
             }
 7858   
 
 7859  4 
             retval.stop = input.LT(-1);
 7860   
 
 7861   
 
 7862  4 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 7863  4 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 7864   
 
 7865   
         }
 7866  0 
         catch (RecognitionException re) {
 7867  0 
             reportError(re);
 7868  0 
             recover(input,re);
 7869  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 7870   
 
 7871   
         }
 7872   
 
 7873  0 
         finally {
 7874   
                 // do for sure before leaving
 7875  4 
         }
 7876  4 
         return retval;
 7877   
     }
 7878   
     // $ANTLR end "graphRef"
 7879   
 
 7880   
 
 7881  16 
     public static class graphRefAll_return extends ParserRuleReturnScope {
 7882   
         Object tree;
 7883  16 
         public Object getTree() { return tree; }
 7884   
     };
 7885   
 
 7886   
 
 7887   
     // $ANTLR start "graphRefAll"
 7888   
     // com\\googlecode\\sparkleg\\Sparql.g:262:1: graphRefAll : ( graphRef | DEFAULT | NAMED | ALL );
 7889   
     public final SparqlParser.graphRefAll_return graphRefAll() throws RecognitionException {
 7890  16 
         SparqlParser.graphRefAll_return retval = new SparqlParser.graphRefAll_return();
 7891  16 
         retval.start = input.LT(1);
 7892   
 
 7893   
 
 7894  16 
         Object root_0 = null;
 7895   
 
 7896  16 
         Token DEFAULT175=null;
 7897  16 
         Token NAMED176=null;
 7898  16 
         Token ALL177=null;
 7899  16 
         SparqlParser.graphRef_return graphRef174 =null;
 7900   
 
 7901   
 
 7902  16 
         Object DEFAULT175_tree=null;
 7903  16 
         Object NAMED176_tree=null;
 7904  16 
         Object ALL177_tree=null;
 7905   
 
 7906   
         try {
 7907   
             // com\\googlecode\\sparkleg\\Sparql.g:263:5: ( graphRef | DEFAULT | NAMED | ALL )
 7908  16 
             int alt57=4;
 7909  16 
             switch ( input.LA(1) ) {
 7910   
             case GRAPH:
 7911   
                 {
 7912  4 
                 alt57=1;
 7913   
                 }
 7914  4 
                 break;
 7915   
             case DEFAULT:
 7916   
                 {
 7917  4 
                 alt57=2;
 7918   
                 }
 7919  4 
                 break;
 7920   
             case NAMED:
 7921   
                 {
 7922  4 
                 alt57=3;
 7923   
                 }
 7924  4 
                 break;
 7925   
             case ALL:
 7926   
                 {
 7927  4 
                 alt57=4;
 7928   
                 }
 7929  4 
                 break;
 7930   
             default:
 7931  0 
                 NoViableAltException nvae =
 7932   
                     new NoViableAltException("", 57, 0, input);
 7933   
 
 7934  0 
                 throw nvae;
 7935   
 
 7936   
             }
 7937   
 
 7938  16 
             switch (alt57) {
 7939   
                 case 1 :
 7940   
                     // com\\googlecode\\sparkleg\\Sparql.g:263:7: graphRef
 7941   
                     {
 7942  4 
                     root_0 = (Object)adaptor.nil();
 7943   
 
 7944   
 
 7945  4 
                     pushFollow(FOLLOW_graphRef_in_graphRefAll2101);
 7946  4 
                     graphRef174=graphRef();
 7947   
 
 7948  4 
                     state._fsp--;
 7949   
 
 7950  4 
                     adaptor.addChild(root_0, graphRef174.getTree());
 7951   
 
 7952   
                     }
 7953  4 
                     break;
 7954   
                 case 2 :
 7955   
                     // com\\googlecode\\sparkleg\\Sparql.g:263:18: DEFAULT
 7956   
                     {
 7957  4 
                     root_0 = (Object)adaptor.nil();
 7958   
 
 7959   
 
 7960  4 
                     DEFAULT175=(Token)match(input,DEFAULT,FOLLOW_DEFAULT_in_graphRefAll2105);
 7961  4 
                     DEFAULT175_tree =
 7962   
                     (Object)adaptor.create(DEFAULT175)
 7963   
                     ;
 7964  4 
                     adaptor.addChild(root_0, DEFAULT175_tree);
 7965   
 
 7966   
 
 7967   
                     }
 7968  4 
                     break;
 7969   
                 case 3 :
 7970   
                     // com\\googlecode\\sparkleg\\Sparql.g:263:28: NAMED
 7971   
                     {
 7972  4 
                     root_0 = (Object)adaptor.nil();
 7973   
 
 7974   
 
 7975  4 
                     NAMED176=(Token)match(input,NAMED,FOLLOW_NAMED_in_graphRefAll2109);
 7976  4 
                     NAMED176_tree =
 7977   
                     (Object)adaptor.create(NAMED176)
 7978   
                     ;
 7979  4 
                     adaptor.addChild(root_0, NAMED176_tree);
 7980   
 
 7981   
 
 7982   
                     }
 7983  4 
                     break;
 7984   
                 case 4 :
 7985   
                     // com\\googlecode\\sparkleg\\Sparql.g:263:36: ALL
 7986   
                     {
 7987  4 
                     root_0 = (Object)adaptor.nil();
 7988   
 
 7989   
 
 7990  4 
                     ALL177=(Token)match(input,ALL,FOLLOW_ALL_in_graphRefAll2113);
 7991  4 
                     ALL177_tree =
 7992   
                     (Object)adaptor.create(ALL177)
 7993   
                     ;
 7994  4 
                     adaptor.addChild(root_0, ALL177_tree);
 7995   
 
 7996   
 
 7997   
                     }
 7998   
                     break;
 7999   
 
 8000   
             }
 8001  16 
             retval.stop = input.LT(-1);
 8002   
 
 8003   
 
 8004  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8005  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8006   
 
 8007   
         }
 8008  0 
         catch (RecognitionException re) {
 8009  0 
             reportError(re);
 8010  0 
             recover(input,re);
 8011  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8012   
 
 8013   
         }
 8014   
 
 8015  0 
         finally {
 8016   
                 // do for sure before leaving
 8017  16 
         }
 8018  16 
         return retval;
 8019   
     }
 8020   
     // $ANTLR end "graphRefAll"
 8021   
 
 8022   
 
 8023  122 
     public static class quadPattern_return extends ParserRuleReturnScope {
 8024   
         Object tree;
 8025  122 
         public Object getTree() { return tree; }
 8026   
     };
 8027   
 
 8028   
 
 8029   
     // $ANTLR start "quadPattern"
 8030   
     // com\\googlecode\\sparkleg\\Sparql.g:266:1: quadPattern : OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads ;
 8031   
     public final SparqlParser.quadPattern_return quadPattern() throws RecognitionException {
 8032  122 
         SparqlParser.quadPattern_return retval = new SparqlParser.quadPattern_return();
 8033  122 
         retval.start = input.LT(1);
 8034   
 
 8035   
 
 8036  122 
         Object root_0 = null;
 8037   
 
 8038  122 
         Token OPEN_CURLY_BRACE178=null;
 8039  122 
         Token CLOSE_CURLY_BRACE180=null;
 8040  122 
         SparqlParser.quads_return quads179 =null;
 8041   
 
 8042   
 
 8043  122 
         Object OPEN_CURLY_BRACE178_tree=null;
 8044  122 
         Object CLOSE_CURLY_BRACE180_tree=null;
 8045  122 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8046  122 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8047  122 
         RewriteRuleSubtreeStream stream_quads=new RewriteRuleSubtreeStream(adaptor,"rule quads");
 8048   
         try {
 8049   
             // com\\googlecode\\sparkleg\\Sparql.g:267:5: ( OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE -> quads )
 8050   
             // com\\googlecode\\sparkleg\\Sparql.g:267:7: OPEN_CURLY_BRACE quads CLOSE_CURLY_BRACE
 8051   
             {
 8052  122 
             OPEN_CURLY_BRACE178=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2130);
 8053  122 
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE178);
 8054   
 
 8055   
 
 8056  122 
             pushFollow(FOLLOW_quads_in_quadPattern2132);
 8057  122 
             quads179=quads();
 8058   
 
 8059  122 
             state._fsp--;
 8060   
 
 8061  122 
             stream_quads.add(quads179.getTree());
 8062   
 
 8063  122 
             CLOSE_CURLY_BRACE180=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2134);
 8064  122 
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE180);
 8065   
 
 8066   
 
 8067   
             // AST REWRITE
 8068   
             // elements: quads
 8069   
             // token labels:
 8070   
             // rule labels: retval
 8071   
             // token list labels:
 8072   
             // rule list labels:
 8073   
             // wildcard labels:
 8074  122 
             retval.tree = root_0;
 8075  122 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8076   
 
 8077  122 
             root_0 = (Object)adaptor.nil();
 8078   
             // 267:48: -> quads
 8079   
             {
 8080  122 
                 adaptor.addChild(root_0, stream_quads.nextTree());
 8081   
 
 8082   
             }
 8083   
 
 8084   
 
 8085  122 
             retval.tree = root_0;
 8086   
 
 8087   
             }
 8088   
 
 8089  122 
             retval.stop = input.LT(-1);
 8090   
 
 8091   
 
 8092  122 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8093  122 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8094   
 
 8095   
         }
 8096  0 
         catch (RecognitionException re) {
 8097  0 
             reportError(re);
 8098  0 
             recover(input,re);
 8099  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8100   
 
 8101   
         }
 8102   
 
 8103  0 
         finally {
 8104   
                 // do for sure before leaving
 8105  122 
         }
 8106  122 
         return retval;
 8107   
     }
 8108   
     // $ANTLR end "quadPattern"
 8109   
 
 8110   
 
 8111  122 
     public static class quads_return extends ParserRuleReturnScope {
 8112   
         Object tree;
 8113  122 
         public Object getTree() { return tree; }
 8114   
     };
 8115   
 
 8116   
 
 8117   
     // $ANTLR start "quads"
 8118   
     // com\\googlecode\\sparkleg\\Sparql.g:270:1: quads : ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* ;
 8119   
     public final SparqlParser.quads_return quads() throws RecognitionException {
 8120  122 
         SparqlParser.quads_return retval = new SparqlParser.quads_return();
 8121  122 
         retval.start = input.LT(1);
 8122   
 
 8123   
 
 8124  122 
         Object root_0 = null;
 8125   
 
 8126  122 
         SparqlParser.triplesTemplate_return triplesTemplate181 =null;
 8127   
 
 8128  122 
         SparqlParser.quadsDetails_return quadsDetails182 =null;
 8129   
 
 8130   
 
 8131  122 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8132  122 
         RewriteRuleSubtreeStream stream_quadsDetails=new RewriteRuleSubtreeStream(adaptor,"rule quadsDetails");
 8133   
         try {
 8134   
             // com\\googlecode\\sparkleg\\Sparql.g:271:5: ( ( triplesTemplate )? ( quadsDetails )* -> ( triplesTemplate )? ( quadsDetails )* )
 8135   
             // com\\googlecode\\sparkleg\\Sparql.g:271:7: ( triplesTemplate )? ( quadsDetails )*
 8136   
             {
 8137   
             // com\\googlecode\\sparkleg\\Sparql.g:271:7: ( triplesTemplate )?
 8138  122 
             int alt58=2;
 8139  122 
             switch ( input.LA(1) ) {
 8140   
                 case BLANK_NODE_LABEL:
 8141   
                 case DECIMAL:
 8142   
                 case DECIMAL_NEGATIVE:
 8143   
                 case DECIMAL_POSITIVE:
 8144   
                 case DOUBLE:
 8145   
                 case DOUBLE_NEGATIVE:
 8146   
                 case DOUBLE_POSITIVE:
 8147   
                 case FALSE:
 8148   
                 case INTEGER:
 8149   
                 case INTEGER_NEGATIVE:
 8150   
                 case INTEGER_POSITIVE:
 8151   
                 case IRI_REF:
 8152   
                 case OPEN_BRACE:
 8153   
                 case OPEN_SQUARE_BRACKET:
 8154   
                 case PNAME_LN:
 8155   
                 case PNAME_NS:
 8156   
                 case STRING_LITERAL1:
 8157   
                 case STRING_LITERAL2:
 8158   
                 case STRING_LITERAL_LONG1:
 8159   
                 case STRING_LITERAL_LONG2:
 8160   
                 case TRUE:
 8161   
                 case VAR1:
 8162   
                 case VAR2:
 8163   
                     {
 8164  88 
                     alt58=1;
 8165   
                     }
 8166   
                     break;
 8167   
             }
 8168   
 
 8169  122 
             switch (alt58) {
 8170   
                 case 1 :
 8171   
                     // com\\googlecode\\sparkleg\\Sparql.g:271:7: triplesTemplate
 8172   
                     {
 8173  88 
                     pushFollow(FOLLOW_triplesTemplate_in_quads2159);
 8174  88 
                     triplesTemplate181=triplesTemplate();
 8175   
 
 8176  88 
                     state._fsp--;
 8177   
 
 8178  88 
                     stream_triplesTemplate.add(triplesTemplate181.getTree());
 8179   
 
 8180   
                     }
 8181   
                     break;
 8182   
 
 8183   
             }
 8184   
 
 8185   
 
 8186   
             // com\\googlecode\\sparkleg\\Sparql.g:271:24: ( quadsDetails )*
 8187   
             loop59:
 8188   
             do {
 8189  156 
                 int alt59=2;
 8190  156 
                 switch ( input.LA(1) ) {
 8191   
                 case GRAPH:
 8192   
                     {
 8193  34 
                     alt59=1;
 8194   
                     }
 8195   
                     break;
 8196   
 
 8197   
                 }
 8198   
 
 8199  156 
                 switch (alt59) {
 8200   
                     case 1 :
 8201   
                         // com\\googlecode\\sparkleg\\Sparql.g:271:24: quadsDetails
 8202   
                         {
 8203  34 
                         pushFollow(FOLLOW_quadsDetails_in_quads2162);
 8204  34 
                         quadsDetails182=quadsDetails();
 8205   
 
 8206  34 
                         state._fsp--;
 8207   
 
 8208  34 
                         stream_quadsDetails.add(quadsDetails182.getTree());
 8209   
 
 8210   
                         }
 8211  34 
                         break;
 8212   
 
 8213   
                     default :
 8214  122 
                         break loop59;
 8215   
                 }
 8216  34 
             } while (true);
 8217   
 
 8218   
 
 8219   
             // AST REWRITE
 8220   
             // elements: quadsDetails, triplesTemplate
 8221   
             // token labels:
 8222   
             // rule labels: retval
 8223   
             // token list labels:
 8224   
             // rule list labels:
 8225   
             // wildcard labels:
 8226  122 
             retval.tree = root_0;
 8227  122 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8228   
 
 8229  122 
             root_0 = (Object)adaptor.nil();
 8230   
             // 271:38: -> ( triplesTemplate )? ( quadsDetails )*
 8231   
             {
 8232   
                 // com\\googlecode\\sparkleg\\Sparql.g:271:42: ( triplesTemplate )?
 8233  122 
                 if ( stream_triplesTemplate.hasNext() ) {
 8234  88 
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8235   
 
 8236   
                 }
 8237  122 
                 stream_triplesTemplate.reset();
 8238   
 
 8239   
                 // com\\googlecode\\sparkleg\\Sparql.g:271:59: ( quadsDetails )*
 8240  156 
                 while ( stream_quadsDetails.hasNext() ) {
 8241  34 
                     adaptor.addChild(root_0, stream_quadsDetails.nextTree());
 8242   
 
 8243   
                 }
 8244  122 
                 stream_quadsDetails.reset();
 8245   
 
 8246   
             }
 8247   
 
 8248   
 
 8249  122 
             retval.tree = root_0;
 8250   
 
 8251   
             }
 8252   
 
 8253  122 
             retval.stop = input.LT(-1);
 8254   
 
 8255   
 
 8256  122 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8257  122 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8258   
 
 8259   
         }
 8260  0 
         catch (RecognitionException re) {
 8261  0 
             reportError(re);
 8262  0 
             recover(input,re);
 8263  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8264   
 
 8265   
         }
 8266   
 
 8267  0 
         finally {
 8268   
                 // do for sure before leaving
 8269  122 
         }
 8270  122 
         return retval;
 8271   
     }
 8272   
     // $ANTLR end "quads"
 8273   
 
 8274   
 
 8275  34 
     public static class quadsDetails_return extends ParserRuleReturnScope {
 8276   
         Object tree;
 8277  34 
         public Object getTree() { return tree; }
 8278   
     };
 8279   
 
 8280   
 
 8281   
     // $ANTLR start "quadsDetails"
 8282   
     // com\\googlecode\\sparkleg\\Sparql.g:274:1: quadsDetails : quadsNotTriples ( DOT )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? ;
 8283   
     public final SparqlParser.quadsDetails_return quadsDetails() throws RecognitionException {
 8284  34 
         SparqlParser.quadsDetails_return retval = new SparqlParser.quadsDetails_return();
 8285  34 
         retval.start = input.LT(1);
 8286   
 
 8287   
 
 8288  34 
         Object root_0 = null;
 8289   
 
 8290  34 
         Token DOT184=null;
 8291  34 
         SparqlParser.quadsNotTriples_return quadsNotTriples183 =null;
 8292   
 
 8293  34 
         SparqlParser.triplesTemplate_return triplesTemplate185 =null;
 8294   
 
 8295   
 
 8296  34 
         Object DOT184_tree=null;
 8297  34 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8298  34 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8299  34 
         RewriteRuleSubtreeStream stream_quadsNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule quadsNotTriples");
 8300   
         try {
 8301   
             // com\\googlecode\\sparkleg\\Sparql.g:275:5: ( quadsNotTriples ( DOT )? ( triplesTemplate )? -> quadsNotTriples ( triplesTemplate )? )
 8302   
             // com\\googlecode\\sparkleg\\Sparql.g:275:7: quadsNotTriples ( DOT )? ( triplesTemplate )?
 8303   
             {
 8304  34 
             pushFollow(FOLLOW_quadsNotTriples_in_quadsDetails2194);
 8305  34 
             quadsNotTriples183=quadsNotTriples();
 8306   
 
 8307  34 
             state._fsp--;
 8308   
 
 8309  34 
             stream_quadsNotTriples.add(quadsNotTriples183.getTree());
 8310   
 
 8311   
             // com\\googlecode\\sparkleg\\Sparql.g:275:23: ( DOT )?
 8312  34 
             int alt60=2;
 8313  34 
             switch ( input.LA(1) ) {
 8314   
                 case DOT:
 8315   
                     {
 8316  0 
                     alt60=1;
 8317   
                     }
 8318   
                     break;
 8319   
             }
 8320   
 
 8321  34 
             switch (alt60) {
 8322   
                 case 1 :
 8323   
                     // com\\googlecode\\sparkleg\\Sparql.g:275:23: DOT
 8324   
                     {
 8325  0 
                     DOT184=(Token)match(input,DOT,FOLLOW_DOT_in_quadsDetails2196);
 8326  0 
                     stream_DOT.add(DOT184);
 8327   
 
 8328   
 
 8329   
                     }
 8330   
                     break;
 8331   
 
 8332   
             }
 8333   
 
 8334   
 
 8335   
             // com\\googlecode\\sparkleg\\Sparql.g:275:28: ( triplesTemplate )?
 8336  34 
             int alt61=2;
 8337  34 
             switch ( input.LA(1) ) {
 8338   
                 case BLANK_NODE_LABEL:
 8339   
                 case DECIMAL:
 8340   
                 case DECIMAL_NEGATIVE:
 8341   
                 case DECIMAL_POSITIVE:
 8342   
                 case DOUBLE:
 8343   
                 case DOUBLE_NEGATIVE:
 8344   
                 case DOUBLE_POSITIVE:
 8345   
                 case FALSE:
 8346   
                 case INTEGER:
 8347   
                 case INTEGER_NEGATIVE:
 8348   
                 case INTEGER_POSITIVE:
 8349   
                 case IRI_REF:
 8350   
                 case OPEN_BRACE:
 8351   
                 case OPEN_SQUARE_BRACKET:
 8352   
                 case PNAME_LN:
 8353   
                 case PNAME_NS:
 8354   
                 case STRING_LITERAL1:
 8355   
                 case STRING_LITERAL2:
 8356   
                 case STRING_LITERAL_LONG1:
 8357   
                 case STRING_LITERAL_LONG2:
 8358   
                 case TRUE:
 8359   
                 case VAR1:
 8360   
                 case VAR2:
 8361   
                     {
 8362  0 
                     alt61=1;
 8363   
                     }
 8364   
                     break;
 8365   
             }
 8366   
 
 8367  34 
             switch (alt61) {
 8368   
                 case 1 :
 8369   
                     // com\\googlecode\\sparkleg\\Sparql.g:275:28: triplesTemplate
 8370   
                     {
 8371  0 
                     pushFollow(FOLLOW_triplesTemplate_in_quadsDetails2199);
 8372  0 
                     triplesTemplate185=triplesTemplate();
 8373   
 
 8374  0 
                     state._fsp--;
 8375   
 
 8376  0 
                     stream_triplesTemplate.add(triplesTemplate185.getTree());
 8377   
 
 8378   
                     }
 8379   
                     break;
 8380   
 
 8381   
             }
 8382   
 
 8383   
 
 8384   
             // AST REWRITE
 8385   
             // elements: triplesTemplate, quadsNotTriples
 8386   
             // token labels:
 8387   
             // rule labels: retval
 8388   
             // token list labels:
 8389   
             // rule list labels:
 8390   
             // wildcard labels:
 8391  34 
             retval.tree = root_0;
 8392  34 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8393   
 
 8394  34 
             root_0 = (Object)adaptor.nil();
 8395   
             // 275:45: -> quadsNotTriples ( triplesTemplate )?
 8396   
             {
 8397  34 
                 adaptor.addChild(root_0, stream_quadsNotTriples.nextTree());
 8398   
 
 8399   
                 // com\\googlecode\\sparkleg\\Sparql.g:275:64: ( triplesTemplate )?
 8400  34 
                 if ( stream_triplesTemplate.hasNext() ) {
 8401  0 
                     adaptor.addChild(root_0, stream_triplesTemplate.nextTree());
 8402   
 
 8403   
                 }
 8404  34 
                 stream_triplesTemplate.reset();
 8405   
 
 8406   
             }
 8407   
 
 8408   
 
 8409  34 
             retval.tree = root_0;
 8410   
 
 8411   
             }
 8412   
 
 8413  34 
             retval.stop = input.LT(-1);
 8414   
 
 8415   
 
 8416  34 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8417  34 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8418   
 
 8419   
         }
 8420  0 
         catch (RecognitionException re) {
 8421  0 
             reportError(re);
 8422  0 
             recover(input,re);
 8423  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8424   
 
 8425   
         }
 8426   
 
 8427  0 
         finally {
 8428   
                 // do for sure before leaving
 8429  34 
         }
 8430  34 
         return retval;
 8431   
     }
 8432   
     // $ANTLR end "quadsDetails"
 8433   
 
 8434   
 
 8435  34 
     public static class quadsNotTriples_return extends ParserRuleReturnScope {
 8436   
         Object tree;
 8437  34 
         public Object getTree() { return tree; }
 8438   
     };
 8439   
 
 8440   
 
 8441   
     // $ANTLR start "quadsNotTriples"
 8442   
     // com\\googlecode\\sparkleg\\Sparql.g:278:1: quadsNotTriples : GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) ;
 8443   
     public final SparqlParser.quadsNotTriples_return quadsNotTriples() throws RecognitionException {
 8444  34 
         SparqlParser.quadsNotTriples_return retval = new SparqlParser.quadsNotTriples_return();
 8445  34 
         retval.start = input.LT(1);
 8446   
 
 8447   
 
 8448  34 
         Object root_0 = null;
 8449   
 
 8450  34 
         Token GRAPH186=null;
 8451  34 
         Token OPEN_CURLY_BRACE188=null;
 8452  34 
         Token CLOSE_CURLY_BRACE190=null;
 8453  34 
         SparqlParser.varOrIRIref_return varOrIRIref187 =null;
 8454   
 
 8455  34 
         SparqlParser.triplesTemplate_return triplesTemplate189 =null;
 8456   
 
 8457   
 
 8458  34 
         Object GRAPH186_tree=null;
 8459  34 
         Object OPEN_CURLY_BRACE188_tree=null;
 8460  34 
         Object CLOSE_CURLY_BRACE190_tree=null;
 8461  34 
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 8462  34 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8463  34 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8464  34 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 8465  34 
         RewriteRuleSubtreeStream stream_triplesTemplate=new RewriteRuleSubtreeStream(adaptor,"rule triplesTemplate");
 8466   
         try {
 8467   
             // com\\googlecode\\sparkleg\\Sparql.g:279:5: ( GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE -> ^( GRAPH varOrIRIref ( triplesTemplate )? ) )
 8468   
             // com\\googlecode\\sparkleg\\Sparql.g:279:7: GRAPH varOrIRIref OPEN_CURLY_BRACE ( triplesTemplate )? CLOSE_CURLY_BRACE
 8469   
             {
 8470  34 
             GRAPH186=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_quadsNotTriples2229);
 8471  34 
             stream_GRAPH.add(GRAPH186);
 8472   
 
 8473   
 
 8474  34 
             pushFollow(FOLLOW_varOrIRIref_in_quadsNotTriples2231);
 8475  34 
             varOrIRIref187=varOrIRIref();
 8476   
 
 8477  34 
             state._fsp--;
 8478   
 
 8479  34 
             stream_varOrIRIref.add(varOrIRIref187.getTree());
 8480   
 
 8481  34 
             OPEN_CURLY_BRACE188=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2233);
 8482  34 
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE188);
 8483   
 
 8484   
 
 8485   
             // com\\googlecode\\sparkleg\\Sparql.g:279:42: ( triplesTemplate )?
 8486  34 
             int alt62=2;
 8487  34 
             switch ( input.LA(1) ) {
 8488   
                 case BLANK_NODE_LABEL:
 8489   
                 case DECIMAL:
 8490   
                 case DECIMAL_NEGATIVE:
 8491   
                 case DECIMAL_POSITIVE:
 8492   
                 case DOUBLE:
 8493   
                 case DOUBLE_NEGATIVE:
 8494   
                 case DOUBLE_POSITIVE:
 8495   
                 case FALSE:
 8496   
                 case INTEGER:
 8497   
                 case INTEGER_NEGATIVE:
 8498   
                 case INTEGER_POSITIVE:
 8499   
                 case IRI_REF:
 8500   
                 case OPEN_BRACE:
 8501   
                 case OPEN_SQUARE_BRACKET:
 8502   
                 case PNAME_LN:
 8503   
                 case PNAME_NS:
 8504   
                 case STRING_LITERAL1:
 8505   
                 case STRING_LITERAL2:
 8506   
                 case STRING_LITERAL_LONG1:
 8507   
                 case STRING_LITERAL_LONG2:
 8508   
                 case TRUE:
 8509   
                 case VAR1:
 8510   
                 case VAR2:
 8511   
                     {
 8512  34 
                     alt62=1;
 8513   
                     }
 8514   
                     break;
 8515   
             }
 8516   
 
 8517  34 
             switch (alt62) {
 8518   
                 case 1 :
 8519   
                     // com\\googlecode\\sparkleg\\Sparql.g:279:42: triplesTemplate
 8520   
                     {
 8521  34 
                     pushFollow(FOLLOW_triplesTemplate_in_quadsNotTriples2235);
 8522  34 
                     triplesTemplate189=triplesTemplate();
 8523   
 
 8524  34 
                     state._fsp--;
 8525   
 
 8526  34 
                     stream_triplesTemplate.add(triplesTemplate189.getTree());
 8527   
 
 8528   
                     }
 8529   
                     break;
 8530   
 
 8531   
             }
 8532   
 
 8533   
 
 8534  34 
             CLOSE_CURLY_BRACE190=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2238);
 8535  34 
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE190);
 8536   
 
 8537   
 
 8538   
             // AST REWRITE
 8539   
             // elements: varOrIRIref, triplesTemplate, GRAPH
 8540   
             // token labels:
 8541   
             // rule labels: retval
 8542   
             // token list labels:
 8543   
             // rule list labels:
 8544   
             // wildcard labels:
 8545  34 
             retval.tree = root_0;
 8546  34 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8547   
 
 8548  34 
             root_0 = (Object)adaptor.nil();
 8549   
             // 279:77: -> ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8550   
             {
 8551   
                 // com\\googlecode\\sparkleg\\Sparql.g:279:80: ^( GRAPH varOrIRIref ( triplesTemplate )? )
 8552   
                 {
 8553  34 
                 Object root_1 = (Object)adaptor.nil();
 8554  34 
                 root_1 = (Object)adaptor.becomeRoot(
 8555   
                 stream_GRAPH.nextNode()
 8556   
                 , root_1);
 8557   
 
 8558  34 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 8559   
 
 8560   
                 // com\\googlecode\\sparkleg\\Sparql.g:279:100: ( triplesTemplate )?
 8561  34 
                 if ( stream_triplesTemplate.hasNext() ) {
 8562  34 
                     adaptor.addChild(root_1, stream_triplesTemplate.nextTree());
 8563   
 
 8564   
                 }
 8565  34 
                 stream_triplesTemplate.reset();
 8566   
 
 8567  34 
                 adaptor.addChild(root_0, root_1);
 8568   
                 }
 8569   
 
 8570   
             }
 8571   
 
 8572   
 
 8573  34 
             retval.tree = root_0;
 8574   
 
 8575   
             }
 8576   
 
 8577  34 
             retval.stop = input.LT(-1);
 8578   
 
 8579   
 
 8580  34 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8581  34 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8582   
 
 8583   
         }
 8584  0 
         catch (RecognitionException re) {
 8585  0 
             reportError(re);
 8586  0 
             recover(input,re);
 8587  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8588   
 
 8589   
         }
 8590   
 
 8591  0 
         finally {
 8592   
                 // do for sure before leaving
 8593  34 
         }
 8594  34 
         return retval;
 8595   
     }
 8596   
     // $ANTLR end "quadsNotTriples"
 8597   
 
 8598   
 
 8599  122 
     public static class triplesTemplate_return extends ParserRuleReturnScope {
 8600   
         Object tree;
 8601  122 
         public Object getTree() { return tree; }
 8602   
     };
 8603   
 
 8604   
 
 8605   
     // $ANTLR start "triplesTemplate"
 8606   
     // com\\googlecode\\sparkleg\\Sparql.g:282:1: triplesTemplate : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) ;
 8607   
     public final SparqlParser.triplesTemplate_return triplesTemplate() throws RecognitionException {
 8608  122 
         SparqlParser.triplesTemplate_return retval = new SparqlParser.triplesTemplate_return();
 8609  122 
         retval.start = input.LT(1);
 8610   
 
 8611   
 
 8612  122 
         Object root_0 = null;
 8613   
 
 8614  122 
         Token DOT192=null;
 8615  122 
         Token DOT194=null;
 8616  122 
         SparqlParser.triplesSameSubject_return triplesSameSubject191 =null;
 8617   
 
 8618  122 
         SparqlParser.triplesSameSubject_return triplesSameSubject193 =null;
 8619   
 
 8620   
 
 8621  122 
         Object DOT192_tree=null;
 8622  122 
         Object DOT194_tree=null;
 8623  122 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 8624  122 
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 8625   
         try {
 8626   
             // com\\googlecode\\sparkleg\\Sparql.g:283:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* ) )
 8627   
             // com\\googlecode\\sparkleg\\Sparql.g:283:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 8628   
             {
 8629  122 
             pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2270);
 8630  122 
             triplesSameSubject191=triplesSameSubject();
 8631   
 
 8632  122 
             state._fsp--;
 8633   
 
 8634  122 
             stream_triplesSameSubject.add(triplesSameSubject191.getTree());
 8635   
 
 8636   
             // com\\googlecode\\sparkleg\\Sparql.g:283:26: ( DOT triplesSameSubject )*
 8637   
             loop63:
 8638   
             do {
 8639  126 
                 int alt63=2;
 8640  126 
                 switch ( input.LA(1) ) {
 8641   
                 case DOT:
 8642   
                     {
 8643  104 
                     switch ( input.LA(2) ) {
 8644   
                     case BLANK_NODE_LABEL:
 8645   
                     case DECIMAL:
 8646   
                     case DECIMAL_NEGATIVE:
 8647   
                     case DECIMAL_POSITIVE:
 8648   
                     case DOUBLE:
 8649   
                     case DOUBLE_NEGATIVE:
 8650   
                     case DOUBLE_POSITIVE:
 8651   
                     case FALSE:
 8652   
                     case INTEGER:
 8653   
                     case INTEGER_NEGATIVE:
 8654   
                     case INTEGER_POSITIVE:
 8655   
                     case IRI_REF:
 8656   
                     case OPEN_BRACE:
 8657   
                     case OPEN_SQUARE_BRACKET:
 8658   
                     case PNAME_LN:
 8659   
                     case PNAME_NS:
 8660   
                     case STRING_LITERAL1:
 8661   
                     case STRING_LITERAL2:
 8662   
                     case STRING_LITERAL_LONG1:
 8663   
                     case STRING_LITERAL_LONG2:
 8664   
                     case TRUE:
 8665   
                     case VAR1:
 8666   
                     case VAR2:
 8667   
                         {
 8668  4 
                         alt63=1;
 8669   
                         }
 8670   
                         break;
 8671   
 
 8672   
                     }
 8673   
 
 8674   
                     }
 8675   
                     break;
 8676   
 
 8677   
                 }
 8678   
 
 8679  126 
                 switch (alt63) {
 8680   
                     case 1 :
 8681   
                         // com\\googlecode\\sparkleg\\Sparql.g:283:27: DOT triplesSameSubject
 8682   
                         {
 8683  4 
                         DOT192=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2273);
 8684  4 
                         stream_DOT.add(DOT192);
 8685   
 
 8686   
 
 8687  4 
                         pushFollow(FOLLOW_triplesSameSubject_in_triplesTemplate2275);
 8688  4 
                         triplesSameSubject193=triplesSameSubject();
 8689   
 
 8690  4 
                         state._fsp--;
 8691   
 
 8692  4 
                         stream_triplesSameSubject.add(triplesSameSubject193.getTree());
 8693   
 
 8694   
                         }
 8695  4 
                         break;
 8696   
 
 8697   
                     default :
 8698  122 
                         break loop63;
 8699   
                 }
 8700  4 
             } while (true);
 8701   
 
 8702   
 
 8703   
             // com\\googlecode\\sparkleg\\Sparql.g:283:52: ( DOT )?
 8704  122 
             int alt64=2;
 8705  122 
             switch ( input.LA(1) ) {
 8706   
                 case DOT:
 8707   
                     {
 8708  100 
                     alt64=1;
 8709   
                     }
 8710   
                     break;
 8711   
             }
 8712   
 
 8713  122 
             switch (alt64) {
 8714   
                 case 1 :
 8715   
                     // com\\googlecode\\sparkleg\\Sparql.g:283:52: DOT
 8716   
                     {
 8717  100 
                     DOT194=(Token)match(input,DOT,FOLLOW_DOT_in_triplesTemplate2279);
 8718  100 
                     stream_DOT.add(DOT194);
 8719   
 
 8720   
 
 8721   
                     }
 8722   
                     break;
 8723   
 
 8724   
             }
 8725   
 
 8726   
 
 8727   
             // AST REWRITE
 8728   
             // elements: triplesSameSubject
 8729   
             // token labels:
 8730   
             // rule labels: retval
 8731   
             // token list labels:
 8732   
             // rule list labels:
 8733   
             // wildcard labels:
 8734  122 
             retval.tree = root_0;
 8735  122 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8736   
 
 8737  122 
             root_0 = (Object)adaptor.nil();
 8738   
             // 283:57: -> ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8739   
             {
 8740   
                 // com\\googlecode\\sparkleg\\Sparql.g:283:60: ^( TRIPLES_TEMPLATE ( triplesSameSubject )* )
 8741   
                 {
 8742  122 
                 Object root_1 = (Object)adaptor.nil();
 8743  122 
                 root_1 = (Object)adaptor.becomeRoot(
 8744   
                 (Object)adaptor.create(TRIPLES_TEMPLATE, "TRIPLES_TEMPLATE")
 8745   
                 , root_1);
 8746   
 
 8747   
                 // com\\googlecode\\sparkleg\\Sparql.g:283:79: ( triplesSameSubject )*
 8748  248 
                 while ( stream_triplesSameSubject.hasNext() ) {
 8749  126 
                     adaptor.addChild(root_1, stream_triplesSameSubject.nextTree());
 8750   
 
 8751   
                 }
 8752  122 
                 stream_triplesSameSubject.reset();
 8753   
 
 8754  122 
                 adaptor.addChild(root_0, root_1);
 8755   
                 }
 8756   
 
 8757   
             }
 8758   
 
 8759   
 
 8760  122 
             retval.tree = root_0;
 8761   
 
 8762   
             }
 8763   
 
 8764  122 
             retval.stop = input.LT(-1);
 8765   
 
 8766   
 
 8767  122 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 8768  122 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 8769   
 
 8770   
         }
 8771  0 
         catch (RecognitionException re) {
 8772  0 
             reportError(re);
 8773  0 
             recover(input,re);
 8774  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 8775   
 
 8776   
         }
 8777   
 
 8778  0 
         finally {
 8779   
                 // do for sure before leaving
 8780  122 
         }
 8781  122 
         return retval;
 8782   
     }
 8783   
     // $ANTLR end "triplesTemplate"
 8784   
 
 8785   
 
 8786  2640 
     public static class groupGraphPattern_return extends ParserRuleReturnScope {
 8787   
         Object tree;
 8788  2640 
         public Object getTree() { return tree; }
 8789   
     };
 8790   
 
 8791   
 
 8792   
     // $ANTLR start "groupGraphPattern"
 8793   
     // com\\googlecode\\sparkleg\\Sparql.g:286:1: groupGraphPattern : ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) );
 8794   
     public final SparqlParser.groupGraphPattern_return groupGraphPattern() throws RecognitionException {
 8795  2640 
         SparqlParser.groupGraphPattern_return retval = new SparqlParser.groupGraphPattern_return();
 8796  2640 
         retval.start = input.LT(1);
 8797   
 
 8798   
 
 8799  2640 
         Object root_0 = null;
 8800   
 
 8801  2640 
         Token OPEN_CURLY_BRACE195=null;
 8802  2640 
         Token CLOSE_CURLY_BRACE197=null;
 8803  2640 
         Token OPEN_CURLY_BRACE198=null;
 8804  2640 
         Token CLOSE_CURLY_BRACE200=null;
 8805  2640 
         Token OPEN_CURLY_BRACE201=null;
 8806  2640 
         Token CLOSE_CURLY_BRACE202=null;
 8807  2640 
         SparqlParser.subSelect_return subSelect196 =null;
 8808   
 
 8809  2640 
         SparqlParser.groupGraphPatternSub_return groupGraphPatternSub199 =null;
 8810   
 
 8811   
 
 8812  2640 
         Object OPEN_CURLY_BRACE195_tree=null;
 8813  2640 
         Object CLOSE_CURLY_BRACE197_tree=null;
 8814  2640 
         Object OPEN_CURLY_BRACE198_tree=null;
 8815  2640 
         Object CLOSE_CURLY_BRACE200_tree=null;
 8816  2640 
         Object OPEN_CURLY_BRACE201_tree=null;
 8817  2640 
         Object CLOSE_CURLY_BRACE202_tree=null;
 8818  2640 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 8819  2640 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 8820  2640 
         RewriteRuleSubtreeStream stream_groupGraphPatternSub=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSub");
 8821  2640 
         RewriteRuleSubtreeStream stream_subSelect=new RewriteRuleSubtreeStream(adaptor,"rule subSelect");
 8822   
         try {
 8823   
             // com\\googlecode\\sparkleg\\Sparql.g:287:5: ( OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN subSelect ) | OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub ) | OPEN_CURLY_BRACE CLOSE_CURLY_BRACE -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN ) )
 8824  2640 
             int alt65=3;
 8825  2640 
             switch ( input.LA(1) ) {
 8826   
             case OPEN_CURLY_BRACE:
 8827   
                 {
 8828  2640 
                 switch ( input.LA(2) ) {
 8829   
                 case CLOSE_CURLY_BRACE:
 8830   
                     {
 8831  44 
                     alt65=3;
 8832   
                     }
 8833  44 
                     break;
 8834   
                 case SELECT:
 8835   
                     {
 8836  46 
                     alt65=1;
 8837   
                     }
 8838  46 
                     break;
 8839   
                 case BIND:
 8840   
                 case BLANK_NODE_LABEL:
 8841   
                 case DECIMAL:
 8842   
                 case DECIMAL_NEGATIVE:
 8843   
                 case DECIMAL_POSITIVE:
 8844   
                 case DOUBLE:
 8845   
                 case DOUBLE_NEGATIVE:
 8846   
                 case DOUBLE_POSITIVE:
 8847   
                 case FALSE:
 8848   
                 case FILTER:
 8849   
                 case GRAPH:
 8850   
                 case INTEGER:
 8851   
                 case INTEGER_NEGATIVE:
 8852   
                 case INTEGER_POSITIVE:
 8853   
                 case IRI_REF:
 8854   
                 case MINUS_KEYWORD:
 8855   
                 case OPEN_BRACE:
 8856   
                 case OPEN_CURLY_BRACE:
 8857   
                 case OPEN_SQUARE_BRACKET:
 8858   
                 case OPTIONAL:
 8859   
                 case PNAME_LN:
 8860   
                 case PNAME_NS:
 8861   
                 case SERVICE:
 8862   
                 case STRING_LITERAL1:
 8863   
                 case STRING_LITERAL2:
 8864   
                 case STRING_LITERAL_LONG1:
 8865   
                 case STRING_LITERAL_LONG2:
 8866   
                 case TRUE:
 8867   
                 case VAR1:
 8868   
                 case VAR2:
 8869   
                     {
 8870  2550 
                     alt65=2;
 8871   
                     }
 8872  2550 
                     break;
 8873   
                 default:
 8874  0 
                     NoViableAltException nvae =
 8875   
                         new NoViableAltException("", 65, 1, input);
 8876   
 
 8877  0 
                     throw nvae;
 8878   
 
 8879   
                 }
 8880   
 
 8881   
                 }
 8882  2640 
                 break;
 8883   
             default:
 8884  0 
                 NoViableAltException nvae =
 8885   
                     new NoViableAltException("", 65, 0, input);
 8886   
 
 8887  0 
                 throw nvae;
 8888   
 
 8889   
             }
 8890   
 
 8891  2640 
             switch (alt65) {
 8892   
                 case 1 :
 8893   
                     // com\\googlecode\\sparkleg\\Sparql.g:287:7: OPEN_CURLY_BRACE subSelect CLOSE_CURLY_BRACE
 8894   
                     {
 8895  46 
                     OPEN_CURLY_BRACE195=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2311);
 8896  46 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE195);
 8897   
 
 8898   
 
 8899  46 
                     pushFollow(FOLLOW_subSelect_in_groupGraphPattern2313);
 8900  46 
                     subSelect196=subSelect();
 8901   
 
 8902  46 
                     state._fsp--;
 8903   
 
 8904  46 
                     stream_subSelect.add(subSelect196.getTree());
 8905   
 
 8906  46 
                     CLOSE_CURLY_BRACE197=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2315);
 8907  46 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE197);
 8908   
 
 8909   
 
 8910   
                     // AST REWRITE
 8911   
                     // elements: subSelect
 8912   
                     // token labels:
 8913   
                     // rule labels: retval
 8914   
                     // token list labels:
 8915   
                     // rule list labels:
 8916   
                     // wildcard labels:
 8917  46 
                     retval.tree = root_0;
 8918  46 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8919   
 
 8920  46 
                     root_0 = (Object)adaptor.nil();
 8921   
                     // 287:52: -> ^( GROUP_GRAPH_PATTERN subSelect )
 8922   
                     {
 8923   
                         // com\\googlecode\\sparkleg\\Sparql.g:287:55: ^( GROUP_GRAPH_PATTERN subSelect )
 8924   
                         {
 8925  46 
                         Object root_1 = (Object)adaptor.nil();
 8926  46 
                         root_1 = (Object)adaptor.becomeRoot(
 8927   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8928   
                         , root_1);
 8929   
 
 8930  46 
                         adaptor.addChild(root_1, stream_subSelect.nextTree());
 8931   
 
 8932  46 
                         adaptor.addChild(root_0, root_1);
 8933   
                         }
 8934   
 
 8935   
                     }
 8936   
 
 8937   
 
 8938  46 
                     retval.tree = root_0;
 8939   
 
 8940   
                     }
 8941  46 
                     break;
 8942   
                 case 2 :
 8943   
                     // com\\googlecode\\sparkleg\\Sparql.g:288:7: OPEN_CURLY_BRACE groupGraphPatternSub CLOSE_CURLY_BRACE
 8944   
                     {
 8945  2550 
                     OPEN_CURLY_BRACE198=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2331);
 8946  2550 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE198);
 8947   
 
 8948   
 
 8949  2550 
                     pushFollow(FOLLOW_groupGraphPatternSub_in_groupGraphPattern2333);
 8950  2550 
                     groupGraphPatternSub199=groupGraphPatternSub();
 8951   
 
 8952  2550 
                     state._fsp--;
 8953   
 
 8954  2550 
                     stream_groupGraphPatternSub.add(groupGraphPatternSub199.getTree());
 8955   
 
 8956  2550 
                     CLOSE_CURLY_BRACE200=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2335);
 8957  2550 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE200);
 8958   
 
 8959   
 
 8960   
                     // AST REWRITE
 8961   
                     // elements: groupGraphPatternSub
 8962   
                     // token labels:
 8963   
                     // rule labels: retval
 8964   
                     // token list labels:
 8965   
                     // rule list labels:
 8966   
                     // wildcard labels:
 8967  2550 
                     retval.tree = root_0;
 8968  2550 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 8969   
 
 8970  2550 
                     root_0 = (Object)adaptor.nil();
 8971   
                     // 288:63: -> ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8972   
                     {
 8973   
                         // com\\googlecode\\sparkleg\\Sparql.g:288:66: ^( GROUP_GRAPH_PATTERN groupGraphPatternSub )
 8974   
                         {
 8975  2550 
                         Object root_1 = (Object)adaptor.nil();
 8976  2550 
                         root_1 = (Object)adaptor.becomeRoot(
 8977   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 8978   
                         , root_1);
 8979   
 
 8980  2550 
                         adaptor.addChild(root_1, stream_groupGraphPatternSub.nextTree());
 8981   
 
 8982  2550 
                         adaptor.addChild(root_0, root_1);
 8983   
                         }
 8984   
 
 8985   
                     }
 8986   
 
 8987   
 
 8988  2550 
                     retval.tree = root_0;
 8989   
 
 8990   
                     }
 8991  2550 
                     break;
 8992   
                 case 3 :
 8993   
                     // com\\googlecode\\sparkleg\\Sparql.g:289:7: OPEN_CURLY_BRACE CLOSE_CURLY_BRACE
 8994   
                     {
 8995  44 
                     OPEN_CURLY_BRACE201=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2351);
 8996  44 
                     stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE201);
 8997   
 
 8998   
 
 8999  44 
                     CLOSE_CURLY_BRACE202=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2353);
 9000  44 
                     stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE202);
 9001   
 
 9002   
 
 9003   
                     // AST REWRITE
 9004   
                     // elements:
 9005   
                     // token labels:
 9006   
                     // rule labels: retval
 9007   
                     // token list labels:
 9008   
                     // rule list labels:
 9009   
                     // wildcard labels:
 9010  44 
                     retval.tree = root_0;
 9011  44 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9012   
 
 9013  44 
                     root_0 = (Object)adaptor.nil();
 9014   
                     // 289:42: -> ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9015   
                     {
 9016   
                         // com\\googlecode\\sparkleg\\Sparql.g:289:45: ^( GROUP_GRAPH_PATTERN GROUP_GRAPH_PATTERN )
 9017   
                         {
 9018  44 
                         Object root_1 = (Object)adaptor.nil();
 9019  44 
                         root_1 = (Object)adaptor.becomeRoot(
 9020   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9021   
                         , root_1);
 9022   
 
 9023  44 
                         adaptor.addChild(root_1,
 9024   
                         (Object)adaptor.create(GROUP_GRAPH_PATTERN, "GROUP_GRAPH_PATTERN")
 9025   
                         );
 9026   
 
 9027  44 
                         adaptor.addChild(root_0, root_1);
 9028   
                         }
 9029   
 
 9030   
                     }
 9031   
 
 9032   
 
 9033  44 
                     retval.tree = root_0;
 9034   
 
 9035   
                     }
 9036   
                     break;
 9037   
 
 9038   
             }
 9039  2640 
             retval.stop = input.LT(-1);
 9040   
 
 9041   
 
 9042  2640 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9043  2640 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9044   
 
 9045   
         }
 9046  0 
         catch (RecognitionException re) {
 9047  0 
             reportError(re);
 9048  0 
             recover(input,re);
 9049  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9050   
 
 9051   
         }
 9052   
 
 9053  0 
         finally {
 9054   
                 // do for sure before leaving
 9055  2640 
         }
 9056  2640 
         return retval;
 9057   
     }
 9058   
     // $ANTLR end "groupGraphPattern"
 9059   
 
 9060   
 
 9061  2550 
     public static class groupGraphPatternSub_return extends ParserRuleReturnScope {
 9062   
         Object tree;
 9063  2550 
         public Object getTree() { return tree; }
 9064   
     };
 9065   
 
 9066   
 
 9067   
     // $ANTLR start "groupGraphPatternSub"
 9068   
     // com\\googlecode\\sparkleg\\Sparql.g:292:1: groupGraphPatternSub : ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ );
 9069   
     public final SparqlParser.groupGraphPatternSub_return groupGraphPatternSub() throws RecognitionException {
 9070  2550 
         SparqlParser.groupGraphPatternSub_return retval = new SparqlParser.groupGraphPatternSub_return();
 9071  2550 
         retval.start = input.LT(1);
 9072   
 
 9073   
 
 9074  2550 
         Object root_0 = null;
 9075   
 
 9076  2550 
         SparqlParser.triplesBlock_return triplesBlock203 =null;
 9077   
 
 9078  2550 
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail204 =null;
 9079   
 
 9080  2550 
         SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail205 =null;
 9081   
 
 9082   
 
 9083  2550 
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9084  2550 
         RewriteRuleSubtreeStream stream_groupGraphPatternSubDetail=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPatternSubDetail");
 9085   
         try {
 9086   
             // com\\googlecode\\sparkleg\\Sparql.g:293:5: ( triplesBlock ( groupGraphPatternSubDetail )* -> triplesBlock ( groupGraphPatternSubDetail )* | ( groupGraphPatternSubDetail )+ -> ( groupGraphPatternSubDetail )+ )
 9087  2550 
             int alt68=2;
 9088  2550 
             switch ( input.LA(1) ) {
 9089   
             case BLANK_NODE_LABEL:
 9090   
             case DECIMAL:
 9091   
             case DECIMAL_NEGATIVE:
 9092   
             case DECIMAL_POSITIVE:
 9093   
             case DOUBLE:
 9094   
             case DOUBLE_NEGATIVE:
 9095   
             case DOUBLE_POSITIVE:
 9096   
             case FALSE:
 9097   
             case INTEGER:
 9098   
             case INTEGER_NEGATIVE:
 9099   
             case INTEGER_POSITIVE:
 9100   
             case IRI_REF:
 9101   
             case OPEN_BRACE:
 9102   
             case OPEN_SQUARE_BRACKET:
 9103   
             case PNAME_LN:
 9104   
             case PNAME_NS:
 9105   
             case STRING_LITERAL1:
 9106   
             case STRING_LITERAL2:
 9107   
             case STRING_LITERAL_LONG1:
 9108   
             case STRING_LITERAL_LONG2:
 9109   
             case TRUE:
 9110   
             case VAR1:
 9111   
             case VAR2:
 9112   
                 {
 9113  2270 
                 alt68=1;
 9114   
                 }
 9115  2270 
                 break;
 9116   
             case BIND:
 9117   
             case FILTER:
 9118   
             case GRAPH:
 9119   
             case MINUS_KEYWORD:
 9120   
             case OPEN_CURLY_BRACE:
 9121   
             case OPTIONAL:
 9122   
             case SERVICE:
 9123   
                 {
 9124  280 
                 alt68=2;
 9125   
                 }
 9126  280 
                 break;
 9127   
             default:
 9128  0 
                 NoViableAltException nvae =
 9129   
                     new NoViableAltException("", 68, 0, input);
 9130   
 
 9131  0 
                 throw nvae;
 9132   
 
 9133   
             }
 9134   
 
 9135  2550 
             switch (alt68) {
 9136   
                 case 1 :
 9137   
                     // com\\googlecode\\sparkleg\\Sparql.g:293:7: triplesBlock ( groupGraphPatternSubDetail )*
 9138   
                     {
 9139  2270 
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSub2382);
 9140  2270 
                     triplesBlock203=triplesBlock();
 9141   
 
 9142  2270 
                     state._fsp--;
 9143   
 
 9144  2270 
                     stream_triplesBlock.add(triplesBlock203.getTree());
 9145   
 
 9146   
                     // com\\googlecode\\sparkleg\\Sparql.g:293:20: ( groupGraphPatternSubDetail )*
 9147   
                     loop66:
 9148   
                     do {
 9149  3144 
                         int alt66=2;
 9150  3144 
                         switch ( input.LA(1) ) {
 9151   
                         case BIND:
 9152   
                         case FILTER:
 9153   
                         case GRAPH:
 9154   
                         case MINUS_KEYWORD:
 9155   
                         case OPEN_CURLY_BRACE:
 9156   
                         case OPTIONAL:
 9157   
                         case SERVICE:
 9158   
                             {
 9159  874 
                             alt66=1;
 9160   
                             }
 9161   
                             break;
 9162   
 
 9163   
                         }
 9164   
 
 9165  3144 
                         switch (alt66) {
 9166   
                             case 1 :
 9167   
                                 // com\\googlecode\\sparkleg\\Sparql.g:293:20: groupGraphPatternSubDetail
 9168   
                                 {
 9169  874 
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2384);
 9170  874 
                                 groupGraphPatternSubDetail204=groupGraphPatternSubDetail();
 9171   
 
 9172  874 
                                 state._fsp--;
 9173   
 
 9174  874 
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail204.getTree());
 9175   
 
 9176   
                                 }
 9177  874 
                                 break;
 9178   
 
 9179   
                             default :
 9180  2270 
                                 break loop66;
 9181   
                         }
 9182  874 
                     } while (true);
 9183   
 
 9184   
 
 9185   
                     // AST REWRITE
 9186   
                     // elements: groupGraphPatternSubDetail, triplesBlock
 9187   
                     // token labels:
 9188   
                     // rule labels: retval
 9189   
                     // token list labels:
 9190   
                     // rule list labels:
 9191   
                     // wildcard labels:
 9192  2270 
                     retval.tree = root_0;
 9193  2270 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9194   
 
 9195  2270 
                     root_0 = (Object)adaptor.nil();
 9196   
                     // 293:48: -> triplesBlock ( groupGraphPatternSubDetail )*
 9197   
                     {
 9198  2270 
                         adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9199   
 
 9200   
                         // com\\googlecode\\sparkleg\\Sparql.g:293:64: ( groupGraphPatternSubDetail )*
 9201  3144 
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9202  874 
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9203   
 
 9204   
                         }
 9205  2270 
                         stream_groupGraphPatternSubDetail.reset();
 9206   
 
 9207   
                     }
 9208   
 
 9209   
 
 9210  2270 
                     retval.tree = root_0;
 9211   
 
 9212   
                     }
 9213  2270 
                     break;
 9214   
                 case 2 :
 9215   
                     // com\\googlecode\\sparkleg\\Sparql.g:294:7: ( groupGraphPatternSubDetail )+
 9216   
                     {
 9217   
                     // com\\googlecode\\sparkleg\\Sparql.g:294:7: ( groupGraphPatternSubDetail )+
 9218  280 
                     int cnt67=0;
 9219   
                     loop67:
 9220   
                     do {
 9221  624 
                         int alt67=2;
 9222  624 
                         switch ( input.LA(1) ) {
 9223   
                         case BIND:
 9224   
                         case FILTER:
 9225   
                         case GRAPH:
 9226   
                         case MINUS_KEYWORD:
 9227   
                         case OPEN_CURLY_BRACE:
 9228   
                         case OPTIONAL:
 9229   
                         case SERVICE:
 9230   
                             {
 9231  344 
                             alt67=1;
 9232   
                             }
 9233   
                             break;
 9234   
 
 9235   
                         }
 9236   
 
 9237  624 
                         switch (alt67) {
 9238   
                             case 1 :
 9239   
                                 // com\\googlecode\\sparkleg\\Sparql.g:294:7: groupGraphPatternSubDetail
 9240   
                                 {
 9241  344 
                                 pushFollow(FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2400);
 9242  344 
                                 groupGraphPatternSubDetail205=groupGraphPatternSubDetail();
 9243   
 
 9244  344 
                                 state._fsp--;
 9245   
 
 9246  344 
                                 stream_groupGraphPatternSubDetail.add(groupGraphPatternSubDetail205.getTree());
 9247   
 
 9248   
                                 }
 9249  344 
                                 break;
 9250   
 
 9251   
                             default :
 9252  280 
                                 if ( cnt67 >= 1 ) break loop67;
 9253  0 
                                 EarlyExitException eee =
 9254   
                                     new EarlyExitException(67, input);
 9255  0 
                                 throw eee;
 9256   
                         }
 9257  344 
                         cnt67++;
 9258  344 
                     } while (true);
 9259   
 
 9260   
 
 9261   
                     // AST REWRITE
 9262   
                     // elements: groupGraphPatternSubDetail
 9263   
                     // token labels:
 9264   
                     // rule labels: retval
 9265   
                     // token list labels:
 9266   
                     // rule list labels:
 9267   
                     // wildcard labels:
 9268  280 
                     retval.tree = root_0;
 9269  280 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9270   
 
 9271  280 
                     root_0 = (Object)adaptor.nil();
 9272   
                     // 294:35: -> ( groupGraphPatternSubDetail )+
 9273   
                     {
 9274  280 
                         if ( !(stream_groupGraphPatternSubDetail.hasNext()) ) {
 9275  0 
                             throw new RewriteEarlyExitException();
 9276   
                         }
 9277  624 
                         while ( stream_groupGraphPatternSubDetail.hasNext() ) {
 9278  344 
                             adaptor.addChild(root_0, stream_groupGraphPatternSubDetail.nextTree());
 9279   
 
 9280   
                         }
 9281  280 
                         stream_groupGraphPatternSubDetail.reset();
 9282   
 
 9283   
                     }
 9284   
 
 9285   
 
 9286  280 
                     retval.tree = root_0;
 9287   
 
 9288   
                     }
 9289   
                     break;
 9290   
 
 9291   
             }
 9292  2550 
             retval.stop = input.LT(-1);
 9293   
 
 9294   
 
 9295  2550 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9296  2550 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9297   
 
 9298   
         }
 9299  0 
         catch (RecognitionException re) {
 9300  0 
             reportError(re);
 9301  0 
             recover(input,re);
 9302  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9303   
 
 9304   
         }
 9305   
 
 9306  0 
         finally {
 9307   
                 // do for sure before leaving
 9308  2550 
         }
 9309  2550 
         return retval;
 9310   
     }
 9311   
     // $ANTLR end "groupGraphPatternSub"
 9312   
 
 9313   
 
 9314  1218 
     public static class groupGraphPatternSubDetail_return extends ParserRuleReturnScope {
 9315   
         Object tree;
 9316  1218 
         public Object getTree() { return tree; }
 9317   
     };
 9318   
 
 9319   
 
 9320   
     // $ANTLR start "groupGraphPatternSubDetail"
 9321   
     // com\\googlecode\\sparkleg\\Sparql.g:297:1: groupGraphPatternSubDetail : graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? ;
 9322   
     public final SparqlParser.groupGraphPatternSubDetail_return groupGraphPatternSubDetail() throws RecognitionException {
 9323  1218 
         SparqlParser.groupGraphPatternSubDetail_return retval = new SparqlParser.groupGraphPatternSubDetail_return();
 9324  1218 
         retval.start = input.LT(1);
 9325   
 
 9326   
 
 9327  1218 
         Object root_0 = null;
 9328   
 
 9329  1218 
         Token DOT207=null;
 9330  1218 
         SparqlParser.graphPatternNotTriples_return graphPatternNotTriples206 =null;
 9331   
 
 9332  1218 
         SparqlParser.triplesBlock_return triplesBlock208 =null;
 9333   
 
 9334   
 
 9335  1218 
         Object DOT207_tree=null;
 9336  1218 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9337  1218 
         RewriteRuleSubtreeStream stream_triplesBlock=new RewriteRuleSubtreeStream(adaptor,"rule triplesBlock");
 9338  1218 
         RewriteRuleSubtreeStream stream_graphPatternNotTriples=new RewriteRuleSubtreeStream(adaptor,"rule graphPatternNotTriples");
 9339   
         try {
 9340   
             // com\\googlecode\\sparkleg\\Sparql.g:298:5: ( graphPatternNotTriples ( DOT )? ( triplesBlock )? -> graphPatternNotTriples ( triplesBlock )? )
 9341   
             // com\\googlecode\\sparkleg\\Sparql.g:298:7: graphPatternNotTriples ( DOT )? ( triplesBlock )?
 9342   
             {
 9343  1218 
             pushFollow(FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2423);
 9344  1218 
             graphPatternNotTriples206=graphPatternNotTriples();
 9345   
 
 9346  1218 
             state._fsp--;
 9347   
 
 9348  1218 
             stream_graphPatternNotTriples.add(graphPatternNotTriples206.getTree());
 9349   
 
 9350   
             // com\\googlecode\\sparkleg\\Sparql.g:298:30: ( DOT )?
 9351  1218 
             int alt69=2;
 9352  1218 
             switch ( input.LA(1) ) {
 9353   
                 case DOT:
 9354   
                     {
 9355  98 
                     alt69=1;
 9356   
                     }
 9357   
                     break;
 9358   
             }
 9359   
 
 9360  1218 
             switch (alt69) {
 9361   
                 case 1 :
 9362   
                     // com\\googlecode\\sparkleg\\Sparql.g:298:30: DOT
 9363   
                     {
 9364  98 
                     DOT207=(Token)match(input,DOT,FOLLOW_DOT_in_groupGraphPatternSubDetail2425);
 9365  98 
                     stream_DOT.add(DOT207);
 9366   
 
 9367   
 
 9368   
                     }
 9369   
                     break;
 9370   
 
 9371   
             }
 9372   
 
 9373   
 
 9374   
             // com\\googlecode\\sparkleg\\Sparql.g:298:35: ( triplesBlock )?
 9375  1218 
             int alt70=2;
 9376  1218 
             switch ( input.LA(1) ) {
 9377   
                 case BLANK_NODE_LABEL:
 9378   
                 case DECIMAL:
 9379   
                 case DECIMAL_NEGATIVE:
 9380   
                 case DECIMAL_POSITIVE:
 9381   
                 case DOUBLE:
 9382   
                 case DOUBLE_NEGATIVE:
 9383   
                 case DOUBLE_POSITIVE:
 9384   
                 case FALSE:
 9385   
                 case INTEGER:
 9386   
                 case INTEGER_NEGATIVE:
 9387   
                 case INTEGER_POSITIVE:
 9388   
                 case IRI_REF:
 9389   
                 case OPEN_BRACE:
 9390   
                 case OPEN_SQUARE_BRACKET:
 9391   
                 case PNAME_LN:
 9392   
                 case PNAME_NS:
 9393   
                 case STRING_LITERAL1:
 9394   
                 case STRING_LITERAL2:
 9395   
                 case STRING_LITERAL_LONG1:
 9396   
                 case STRING_LITERAL_LONG2:
 9397   
                 case TRUE:
 9398   
                 case VAR1:
 9399   
                 case VAR2:
 9400   
                     {
 9401  78 
                     alt70=1;
 9402   
                     }
 9403   
                     break;
 9404   
             }
 9405   
 
 9406  1218 
             switch (alt70) {
 9407   
                 case 1 :
 9408   
                     // com\\googlecode\\sparkleg\\Sparql.g:298:35: triplesBlock
 9409   
                     {
 9410  78 
                     pushFollow(FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2428);
 9411  78 
                     triplesBlock208=triplesBlock();
 9412   
 
 9413  78 
                     state._fsp--;
 9414   
 
 9415  78 
                     stream_triplesBlock.add(triplesBlock208.getTree());
 9416   
 
 9417   
                     }
 9418   
                     break;
 9419   
 
 9420   
             }
 9421   
 
 9422   
 
 9423   
             // AST REWRITE
 9424   
             // elements: triplesBlock, graphPatternNotTriples
 9425   
             // token labels:
 9426   
             // rule labels: retval
 9427   
             // token list labels:
 9428   
             // rule list labels:
 9429   
             // wildcard labels:
 9430  1218 
             retval.tree = root_0;
 9431  1218 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9432   
 
 9433  1218 
             root_0 = (Object)adaptor.nil();
 9434   
             // 298:49: -> graphPatternNotTriples ( triplesBlock )?
 9435   
             {
 9436  1218 
                 adaptor.addChild(root_0, stream_graphPatternNotTriples.nextTree());
 9437   
 
 9438   
                 // com\\googlecode\\sparkleg\\Sparql.g:298:75: ( triplesBlock )?
 9439  1218 
                 if ( stream_triplesBlock.hasNext() ) {
 9440  78 
                     adaptor.addChild(root_0, stream_triplesBlock.nextTree());
 9441   
 
 9442   
                 }
 9443  1218 
                 stream_triplesBlock.reset();
 9444   
 
 9445   
             }
 9446   
 
 9447   
 
 9448  1218 
             retval.tree = root_0;
 9449   
 
 9450   
             }
 9451   
 
 9452  1218 
             retval.stop = input.LT(-1);
 9453   
 
 9454   
 
 9455  1218 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9456  1218 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9457   
 
 9458   
         }
 9459  0 
         catch (RecognitionException re) {
 9460  0 
             reportError(re);
 9461  0 
             recover(input,re);
 9462  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9463   
 
 9464   
         }
 9465   
 
 9466  0 
         finally {
 9467   
                 // do for sure before leaving
 9468  1218 
         }
 9469  1218 
         return retval;
 9470   
     }
 9471   
     // $ANTLR end "groupGraphPatternSubDetail"
 9472   
 
 9473   
 
 9474  2348 
     public static class triplesBlock_return extends ParserRuleReturnScope {
 9475   
         Object tree;
 9476  2348 
         public Object getTree() { return tree; }
 9477   
     };
 9478   
 
 9479   
 
 9480   
     // $ANTLR start "triplesBlock"
 9481   
     // com\\googlecode\\sparkleg\\Sparql.g:301:1: triplesBlock : triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ ;
 9482   
     public final SparqlParser.triplesBlock_return triplesBlock() throws RecognitionException {
 9483  2348 
         SparqlParser.triplesBlock_return retval = new SparqlParser.triplesBlock_return();
 9484  2348 
         retval.start = input.LT(1);
 9485   
 
 9486   
 
 9487  2348 
         Object root_0 = null;
 9488   
 
 9489  2348 
         Token DOT210=null;
 9490  2348 
         Token DOT212=null;
 9491  2348 
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath209 =null;
 9492   
 
 9493  2348 
         SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath211 =null;
 9494   
 
 9495   
 
 9496  2348 
         Object DOT210_tree=null;
 9497  2348 
         Object DOT212_tree=null;
 9498  2348 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 9499  2348 
         RewriteRuleSubtreeStream stream_triplesSameSubjectPath=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubjectPath");
 9500   
         try {
 9501   
             // com\\googlecode\\sparkleg\\Sparql.g:302:5: ( triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )? -> ( triplesSameSubjectPath )+ )
 9502   
             // com\\googlecode\\sparkleg\\Sparql.g:302:7: triplesSameSubjectPath ( DOT triplesSameSubjectPath )* ( DOT )?
 9503   
             {
 9504  2348 
             pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2453);
 9505  2348 
             triplesSameSubjectPath209=triplesSameSubjectPath();
 9506   
 
 9507  2348 
             state._fsp--;
 9508   
 
 9509  2348 
             stream_triplesSameSubjectPath.add(triplesSameSubjectPath209.getTree());
 9510   
 
 9511   
             // com\\googlecode\\sparkleg\\Sparql.g:302:30: ( DOT triplesSameSubjectPath )*
 9512   
             loop71:
 9513   
             do {
 9514  2914 
                 int alt71=2;
 9515  2914 
                 switch ( input.LA(1) ) {
 9516   
                 case DOT:
 9517   
                     {
 9518  1018 
                     switch ( input.LA(2) ) {
 9519   
                     case BLANK_NODE_LABEL:
 9520   
                     case DECIMAL:
 9521   
                     case DECIMAL_NEGATIVE:
 9522   
                     case DECIMAL_POSITIVE:
 9523   
                     case DOUBLE:
 9524   
                     case DOUBLE_NEGATIVE:
 9525   
                     case DOUBLE_POSITIVE:
 9526   
                     case FALSE:
 9527   
                     case INTEGER:
 9528   
                     case INTEGER_NEGATIVE:
 9529   
                     case INTEGER_POSITIVE:
 9530   
                     case IRI_REF:
 9531   
                     case OPEN_BRACE:
 9532   
                     case OPEN_SQUARE_BRACKET:
 9533   
                     case PNAME_LN:
 9534   
                     case PNAME_NS:
 9535   
                     case STRING_LITERAL1:
 9536   
                     case STRING_LITERAL2:
 9537   
                     case STRING_LITERAL_LONG1:
 9538   
                     case STRING_LITERAL_LONG2:
 9539   
                     case TRUE:
 9540   
                     case VAR1:
 9541   
                     case VAR2:
 9542   
                         {
 9543  566 
                         alt71=1;
 9544   
                         }
 9545   
                         break;
 9546   
 
 9547   
                     }
 9548   
 
 9549   
                     }
 9550   
                     break;
 9551   
 
 9552   
                 }
 9553   
 
 9554  2914 
                 switch (alt71) {
 9555   
                     case 1 :
 9556   
                         // com\\googlecode\\sparkleg\\Sparql.g:302:31: DOT triplesSameSubjectPath
 9557   
                         {
 9558  566 
                         DOT210=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2456);
 9559  566 
                         stream_DOT.add(DOT210);
 9560   
 
 9561   
 
 9562  566 
                         pushFollow(FOLLOW_triplesSameSubjectPath_in_triplesBlock2458);
 9563  566 
                         triplesSameSubjectPath211=triplesSameSubjectPath();
 9564   
 
 9565  566 
                         state._fsp--;
 9566   
 
 9567  566 
                         stream_triplesSameSubjectPath.add(triplesSameSubjectPath211.getTree());
 9568   
 
 9569   
                         }
 9570  566 
                         break;
 9571   
 
 9572   
                     default :
 9573  2348 
                         break loop71;
 9574   
                 }
 9575  566 
             } while (true);
 9576   
 
 9577   
 
 9578   
             // com\\googlecode\\sparkleg\\Sparql.g:302:60: ( DOT )?
 9579  2348 
             int alt72=2;
 9580  2348 
             switch ( input.LA(1) ) {
 9581   
                 case DOT:
 9582   
                     {
 9583  452 
                     alt72=1;
 9584   
                     }
 9585   
                     break;
 9586   
             }
 9587   
 
 9588  2348 
             switch (alt72) {
 9589   
                 case 1 :
 9590   
                     // com\\googlecode\\sparkleg\\Sparql.g:302:60: DOT
 9591   
                     {
 9592  452 
                     DOT212=(Token)match(input,DOT,FOLLOW_DOT_in_triplesBlock2462);
 9593  452 
                     stream_DOT.add(DOT212);
 9594   
 
 9595   
 
 9596   
                     }
 9597   
                     break;
 9598   
 
 9599   
             }
 9600   
 
 9601   
 
 9602   
             // AST REWRITE
 9603   
             // elements: triplesSameSubjectPath
 9604   
             // token labels:
 9605   
             // rule labels: retval
 9606   
             // token list labels:
 9607   
             // rule list labels:
 9608   
             // wildcard labels:
 9609  2348 
             retval.tree = root_0;
 9610  2348 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9611   
 
 9612  2348 
             root_0 = (Object)adaptor.nil();
 9613   
             // 302:65: -> ( triplesSameSubjectPath )+
 9614   
             {
 9615  2348 
                 if ( !(stream_triplesSameSubjectPath.hasNext()) ) {
 9616  0 
                     throw new RewriteEarlyExitException();
 9617   
                 }
 9618  5262 
                 while ( stream_triplesSameSubjectPath.hasNext() ) {
 9619  2914 
                     adaptor.addChild(root_0, stream_triplesSameSubjectPath.nextTree());
 9620   
 
 9621   
                 }
 9622  2348 
                 stream_triplesSameSubjectPath.reset();
 9623   
 
 9624   
             }
 9625   
 
 9626   
 
 9627  2348 
             retval.tree = root_0;
 9628   
 
 9629   
             }
 9630   
 
 9631  2348 
             retval.stop = input.LT(-1);
 9632   
 
 9633   
 
 9634  2348 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9635  2348 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9636   
 
 9637   
         }
 9638  0 
         catch (RecognitionException re) {
 9639  0 
             reportError(re);
 9640  0 
             recover(input,re);
 9641  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9642   
 
 9643   
         }
 9644   
 
 9645  0 
         finally {
 9646   
                 // do for sure before leaving
 9647  2348 
         }
 9648  2348 
         return retval;
 9649   
     }
 9650   
     // $ANTLR end "triplesBlock"
 9651   
 
 9652   
 
 9653  1218 
     public static class graphPatternNotTriples_return extends ParserRuleReturnScope {
 9654   
         Object tree;
 9655  1218 
         public Object getTree() { return tree; }
 9656   
     };
 9657   
 
 9658   
 
 9659   
     // $ANTLR start "graphPatternNotTriples"
 9660   
     // com\\googlecode\\sparkleg\\Sparql.g:305:1: graphPatternNotTriples : ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind );
 9661   
     public final SparqlParser.graphPatternNotTriples_return graphPatternNotTriples() throws RecognitionException {
 9662  1218 
         SparqlParser.graphPatternNotTriples_return retval = new SparqlParser.graphPatternNotTriples_return();
 9663  1218 
         retval.start = input.LT(1);
 9664   
 
 9665   
 
 9666  1218 
         Object root_0 = null;
 9667   
 
 9668  1218 
         SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern213 =null;
 9669   
 
 9670  1218 
         SparqlParser.optionalGraphPattern_return optionalGraphPattern214 =null;
 9671   
 
 9672  1218 
         SparqlParser.minusGraphPattern_return minusGraphPattern215 =null;
 9673   
 
 9674  1218 
         SparqlParser.graphGraphPattern_return graphGraphPattern216 =null;
 9675   
 
 9676  1218 
         SparqlParser.serviceGraphPattern_return serviceGraphPattern217 =null;
 9677   
 
 9678  1218 
         SparqlParser.filter_return filter218 =null;
 9679   
 
 9680  1218 
         SparqlParser.bind_return bind219 =null;
 9681   
 
 9682   
 
 9683   
 
 9684   
         try {
 9685   
             // com\\googlecode\\sparkleg\\Sparql.g:306:5: ( groupOrUnionGraphPattern | optionalGraphPattern | minusGraphPattern | graphGraphPattern | serviceGraphPattern | filter | bind )
 9686  1218 
             int alt73=7;
 9687  1218 
             switch ( input.LA(1) ) {
 9688   
             case OPEN_CURLY_BRACE:
 9689   
                 {
 9690  176 
                 alt73=1;
 9691   
                 }
 9692  176 
                 break;
 9693   
             case OPTIONAL:
 9694   
                 {
 9695  188 
                 alt73=2;
 9696   
                 }
 9697  188 
                 break;
 9698   
             case MINUS_KEYWORD:
 9699   
                 {
 9700  42 
                 alt73=3;
 9701   
                 }
 9702  42 
                 break;
 9703   
             case GRAPH:
 9704   
                 {
 9705  152 
                 alt73=4;
 9706   
                 }
 9707  152 
                 break;
 9708   
             case SERVICE:
 9709   
                 {
 9710  26 
                 alt73=5;
 9711   
                 }
 9712  26 
                 break;
 9713   
             case FILTER:
 9714   
                 {
 9715  584 
                 alt73=6;
 9716   
                 }
 9717  584 
                 break;
 9718   
             case BIND:
 9719   
                 {
 9720  50 
                 alt73=7;
 9721   
                 }
 9722  50 
                 break;
 9723   
             default:
 9724  0 
                 NoViableAltException nvae =
 9725   
                     new NoViableAltException("", 73, 0, input);
 9726   
 
 9727  0 
                 throw nvae;
 9728   
 
 9729   
             }
 9730   
 
 9731  1218 
             switch (alt73) {
 9732   
                 case 1 :
 9733   
                     // com\\googlecode\\sparkleg\\Sparql.g:306:7: groupOrUnionGraphPattern
 9734   
                     {
 9735  176 
                     root_0 = (Object)adaptor.nil();
 9736   
 
 9737   
 
 9738  176 
                     pushFollow(FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2485);
 9739  176 
                     groupOrUnionGraphPattern213=groupOrUnionGraphPattern();
 9740   
 
 9741  176 
                     state._fsp--;
 9742   
 
 9743  176 
                     adaptor.addChild(root_0, groupOrUnionGraphPattern213.getTree());
 9744   
 
 9745   
                     }
 9746  176 
                     break;
 9747   
                 case 2 :
 9748   
                     // com\\googlecode\\sparkleg\\Sparql.g:306:34: optionalGraphPattern
 9749   
                     {
 9750  188 
                     root_0 = (Object)adaptor.nil();
 9751   
 
 9752   
 
 9753  188 
                     pushFollow(FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2489);
 9754  188 
                     optionalGraphPattern214=optionalGraphPattern();
 9755   
 
 9756  188 
                     state._fsp--;
 9757   
 
 9758  188 
                     adaptor.addChild(root_0, optionalGraphPattern214.getTree());
 9759   
 
 9760   
                     }
 9761  188 
                     break;
 9762   
                 case 3 :
 9763   
                     // com\\googlecode\\sparkleg\\Sparql.g:306:57: minusGraphPattern
 9764   
                     {
 9765  42 
                     root_0 = (Object)adaptor.nil();
 9766   
 
 9767   
 
 9768  42 
                     pushFollow(FOLLOW_minusGraphPattern_in_graphPatternNotTriples2493);
 9769  42 
                     minusGraphPattern215=minusGraphPattern();
 9770   
 
 9771  42 
                     state._fsp--;
 9772   
 
 9773  42 
                     adaptor.addChild(root_0, minusGraphPattern215.getTree());
 9774   
 
 9775   
                     }
 9776  42 
                     break;
 9777   
                 case 4 :
 9778   
                     // com\\googlecode\\sparkleg\\Sparql.g:306:77: graphGraphPattern
 9779   
                     {
 9780  152 
                     root_0 = (Object)adaptor.nil();
 9781   
 
 9782   
 
 9783  152 
                     pushFollow(FOLLOW_graphGraphPattern_in_graphPatternNotTriples2497);
 9784  152 
                     graphGraphPattern216=graphGraphPattern();
 9785   
 
 9786  152 
                     state._fsp--;
 9787   
 
 9788  152 
                     adaptor.addChild(root_0, graphGraphPattern216.getTree());
 9789   
 
 9790   
                     }
 9791  152 
                     break;
 9792   
                 case 5 :
 9793   
                     // com\\googlecode\\sparkleg\\Sparql.g:306:97: serviceGraphPattern
 9794   
                     {
 9795  26 
                     root_0 = (Object)adaptor.nil();
 9796   
 
 9797   
 
 9798  26 
                     pushFollow(FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2501);
 9799  26 
                     serviceGraphPattern217=serviceGraphPattern();
 9800   
 
 9801  26 
                     state._fsp--;
 9802   
 
 9803  26 
                     adaptor.addChild(root_0, serviceGraphPattern217.getTree());
 9804   
 
 9805   
                     }
 9806  26 
                     break;
 9807   
                 case 6 :
 9808   
                     // com\\googlecode\\sparkleg\\Sparql.g:306:119: filter
 9809   
                     {
 9810  584 
                     root_0 = (Object)adaptor.nil();
 9811   
 
 9812   
 
 9813  584 
                     pushFollow(FOLLOW_filter_in_graphPatternNotTriples2505);
 9814  584 
                     filter218=filter();
 9815   
 
 9816  584 
                     state._fsp--;
 9817   
 
 9818  584 
                     adaptor.addChild(root_0, filter218.getTree());
 9819   
 
 9820   
                     }
 9821  584 
                     break;
 9822   
                 case 7 :
 9823   
                     // com\\googlecode\\sparkleg\\Sparql.g:306:128: bind
 9824   
                     {
 9825  50 
                     root_0 = (Object)adaptor.nil();
 9826   
 
 9827   
 
 9828  50 
                     pushFollow(FOLLOW_bind_in_graphPatternNotTriples2509);
 9829  50 
                     bind219=bind();
 9830   
 
 9831  50 
                     state._fsp--;
 9832   
 
 9833  50 
                     adaptor.addChild(root_0, bind219.getTree());
 9834   
 
 9835   
                     }
 9836   
                     break;
 9837   
 
 9838   
             }
 9839  1218 
             retval.stop = input.LT(-1);
 9840   
 
 9841   
 
 9842  1218 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9843  1218 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9844   
 
 9845   
         }
 9846  0 
         catch (RecognitionException re) {
 9847  0 
             reportError(re);
 9848  0 
             recover(input,re);
 9849  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9850   
 
 9851   
         }
 9852   
 
 9853  0 
         finally {
 9854   
                 // do for sure before leaving
 9855  1218 
         }
 9856  1218 
         return retval;
 9857   
     }
 9858   
     // $ANTLR end "graphPatternNotTriples"
 9859   
 
 9860   
 
 9861  188 
     public static class optionalGraphPattern_return extends ParserRuleReturnScope {
 9862   
         Object tree;
 9863  188 
         public Object getTree() { return tree; }
 9864   
     };
 9865   
 
 9866   
 
 9867   
     // $ANTLR start "optionalGraphPattern"
 9868   
     // com\\googlecode\\sparkleg\\Sparql.g:309:1: optionalGraphPattern : OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) ;
 9869   
     public final SparqlParser.optionalGraphPattern_return optionalGraphPattern() throws RecognitionException {
 9870  188 
         SparqlParser.optionalGraphPattern_return retval = new SparqlParser.optionalGraphPattern_return();
 9871  188 
         retval.start = input.LT(1);
 9872   
 
 9873   
 
 9874  188 
         Object root_0 = null;
 9875   
 
 9876  188 
         Token OPTIONAL220=null;
 9877  188 
         SparqlParser.groupGraphPattern_return groupGraphPattern221 =null;
 9878   
 
 9879   
 
 9880  188 
         Object OPTIONAL220_tree=null;
 9881  188 
         RewriteRuleTokenStream stream_OPTIONAL=new RewriteRuleTokenStream(adaptor,"token OPTIONAL");
 9882  188 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9883   
         try {
 9884   
             // com\\googlecode\\sparkleg\\Sparql.g:310:5: ( OPTIONAL groupGraphPattern -> ^( OPTIONAL groupGraphPattern ) )
 9885   
             // com\\googlecode\\sparkleg\\Sparql.g:310:7: OPTIONAL groupGraphPattern
 9886   
             {
 9887  188 
             OPTIONAL220=(Token)match(input,OPTIONAL,FOLLOW_OPTIONAL_in_optionalGraphPattern2526);
 9888  188 
             stream_OPTIONAL.add(OPTIONAL220);
 9889   
 
 9890   
 
 9891  188 
             pushFollow(FOLLOW_groupGraphPattern_in_optionalGraphPattern2528);
 9892  188 
             groupGraphPattern221=groupGraphPattern();
 9893   
 
 9894  188 
             state._fsp--;
 9895   
 
 9896  188 
             stream_groupGraphPattern.add(groupGraphPattern221.getTree());
 9897   
 
 9898   
             // AST REWRITE
 9899   
             // elements: groupGraphPattern, OPTIONAL
 9900   
             // token labels:
 9901   
             // rule labels: retval
 9902   
             // token list labels:
 9903   
             // rule list labels:
 9904   
             // wildcard labels:
 9905  188 
             retval.tree = root_0;
 9906  188 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 9907   
 
 9908  188 
             root_0 = (Object)adaptor.nil();
 9909   
             // 310:34: -> ^( OPTIONAL groupGraphPattern )
 9910   
             {
 9911   
                 // com\\googlecode\\sparkleg\\Sparql.g:310:37: ^( OPTIONAL groupGraphPattern )
 9912   
                 {
 9913  188 
                 Object root_1 = (Object)adaptor.nil();
 9914  188 
                 root_1 = (Object)adaptor.becomeRoot(
 9915   
                 stream_OPTIONAL.nextNode()
 9916   
                 , root_1);
 9917   
 
 9918  188 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 9919   
 
 9920  188 
                 adaptor.addChild(root_0, root_1);
 9921   
                 }
 9922   
 
 9923   
             }
 9924   
 
 9925   
 
 9926  188 
             retval.tree = root_0;
 9927   
 
 9928   
             }
 9929   
 
 9930  188 
             retval.stop = input.LT(-1);
 9931   
 
 9932   
 
 9933  188 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 9934  188 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 9935   
 
 9936   
         }
 9937  0 
         catch (RecognitionException re) {
 9938  0 
             reportError(re);
 9939  0 
             recover(input,re);
 9940  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 9941   
 
 9942   
         }
 9943   
 
 9944  0 
         finally {
 9945   
                 // do for sure before leaving
 9946  188 
         }
 9947  188 
         return retval;
 9948   
     }
 9949   
     // $ANTLR end "optionalGraphPattern"
 9950   
 
 9951   
 
 9952  152 
     public static class graphGraphPattern_return extends ParserRuleReturnScope {
 9953   
         Object tree;
 9954  152 
         public Object getTree() { return tree; }
 9955   
     };
 9956   
 
 9957   
 
 9958   
     // $ANTLR start "graphGraphPattern"
 9959   
     // com\\googlecode\\sparkleg\\Sparql.g:313:1: graphGraphPattern : GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) ;
 9960   
     public final SparqlParser.graphGraphPattern_return graphGraphPattern() throws RecognitionException {
 9961  152 
         SparqlParser.graphGraphPattern_return retval = new SparqlParser.graphGraphPattern_return();
 9962  152 
         retval.start = input.LT(1);
 9963   
 
 9964   
 
 9965  152 
         Object root_0 = null;
 9966   
 
 9967  152 
         Token GRAPH222=null;
 9968  152 
         SparqlParser.varOrIRIref_return varOrIRIref223 =null;
 9969   
 
 9970  152 
         SparqlParser.groupGraphPattern_return groupGraphPattern224 =null;
 9971   
 
 9972   
 
 9973  152 
         Object GRAPH222_tree=null;
 9974  152 
         RewriteRuleTokenStream stream_GRAPH=new RewriteRuleTokenStream(adaptor,"token GRAPH");
 9975  152 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 9976  152 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 9977   
         try {
 9978   
             // com\\googlecode\\sparkleg\\Sparql.g:314:5: ( GRAPH varOrIRIref groupGraphPattern -> ^( GRAPH varOrIRIref groupGraphPattern ) )
 9979   
             // com\\googlecode\\sparkleg\\Sparql.g:314:7: GRAPH varOrIRIref groupGraphPattern
 9980   
             {
 9981  152 
             GRAPH222=(Token)match(input,GRAPH,FOLLOW_GRAPH_in_graphGraphPattern2553);
 9982  152 
             stream_GRAPH.add(GRAPH222);
 9983   
 
 9984   
 
 9985  152 
             pushFollow(FOLLOW_varOrIRIref_in_graphGraphPattern2555);
 9986  152 
             varOrIRIref223=varOrIRIref();
 9987   
 
 9988  152 
             state._fsp--;
 9989   
 
 9990  152 
             stream_varOrIRIref.add(varOrIRIref223.getTree());
 9991   
 
 9992  152 
             pushFollow(FOLLOW_groupGraphPattern_in_graphGraphPattern2557);
 9993  152 
             groupGraphPattern224=groupGraphPattern();
 9994   
 
 9995  152 
             state._fsp--;
 9996   
 
 9997  152 
             stream_groupGraphPattern.add(groupGraphPattern224.getTree());
 9998   
 
 9999   
             // AST REWRITE
 10000   
             // elements: varOrIRIref, GRAPH, groupGraphPattern
 10001   
             // token labels:
 10002   
             // rule labels: retval
 10003   
             // token list labels:
 10004   
             // rule list labels:
 10005   
             // wildcard labels:
 10006  152 
             retval.tree = root_0;
 10007  152 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10008   
 
 10009  152 
             root_0 = (Object)adaptor.nil();
 10010   
             // 314:43: -> ^( GRAPH varOrIRIref groupGraphPattern )
 10011   
             {
 10012   
                 // com\\googlecode\\sparkleg\\Sparql.g:314:46: ^( GRAPH varOrIRIref groupGraphPattern )
 10013   
                 {
 10014  152 
                 Object root_1 = (Object)adaptor.nil();
 10015  152 
                 root_1 = (Object)adaptor.becomeRoot(
 10016   
                 stream_GRAPH.nextNode()
 10017   
                 , root_1);
 10018   
 
 10019  152 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10020   
 
 10021  152 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10022   
 
 10023  152 
                 adaptor.addChild(root_0, root_1);
 10024   
                 }
 10025   
 
 10026   
             }
 10027   
 
 10028   
 
 10029  152 
             retval.tree = root_0;
 10030   
 
 10031   
             }
 10032   
 
 10033  152 
             retval.stop = input.LT(-1);
 10034   
 
 10035   
 
 10036  152 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10037  152 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10038   
 
 10039   
         }
 10040  0 
         catch (RecognitionException re) {
 10041  0 
             reportError(re);
 10042  0 
             recover(input,re);
 10043  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10044   
 
 10045   
         }
 10046   
 
 10047  0 
         finally {
 10048   
                 // do for sure before leaving
 10049  152 
         }
 10050  152 
         return retval;
 10051   
     }
 10052   
     // $ANTLR end "graphGraphPattern"
 10053   
 
 10054   
 
 10055  26 
     public static class serviceGraphPattern_return extends ParserRuleReturnScope {
 10056   
         Object tree;
 10057  26 
         public Object getTree() { return tree; }
 10058   
     };
 10059   
 
 10060   
 
 10061   
     // $ANTLR start "serviceGraphPattern"
 10062   
     // com\\googlecode\\sparkleg\\Sparql.g:317:1: serviceGraphPattern : SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) ;
 10063   
     public final SparqlParser.serviceGraphPattern_return serviceGraphPattern() throws RecognitionException {
 10064  26 
         SparqlParser.serviceGraphPattern_return retval = new SparqlParser.serviceGraphPattern_return();
 10065  26 
         retval.start = input.LT(1);
 10066   
 
 10067   
 
 10068  26 
         Object root_0 = null;
 10069   
 
 10070  26 
         Token SERVICE225=null;
 10071  26 
         Token SILENT226=null;
 10072  26 
         SparqlParser.varOrIRIref_return varOrIRIref227 =null;
 10073   
 
 10074  26 
         SparqlParser.groupGraphPattern_return groupGraphPattern228 =null;
 10075   
 
 10076   
 
 10077  26 
         Object SERVICE225_tree=null;
 10078  26 
         Object SILENT226_tree=null;
 10079  26 
         RewriteRuleTokenStream stream_SILENT=new RewriteRuleTokenStream(adaptor,"token SILENT");
 10080  26 
         RewriteRuleTokenStream stream_SERVICE=new RewriteRuleTokenStream(adaptor,"token SERVICE");
 10081  26 
         RewriteRuleSubtreeStream stream_varOrIRIref=new RewriteRuleSubtreeStream(adaptor,"rule varOrIRIref");
 10082  26 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10083   
         try {
 10084   
             // com\\googlecode\\sparkleg\\Sparql.g:318:5: ( SERVICE ( SILENT )? varOrIRIref groupGraphPattern -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern ) )
 10085   
             // com\\googlecode\\sparkleg\\Sparql.g:318:7: SERVICE ( SILENT )? varOrIRIref groupGraphPattern
 10086   
             {
 10087  26 
             SERVICE225=(Token)match(input,SERVICE,FOLLOW_SERVICE_in_serviceGraphPattern2584);
 10088  26 
             stream_SERVICE.add(SERVICE225);
 10089   
 
 10090   
 
 10091   
             // com\\googlecode\\sparkleg\\Sparql.g:318:15: ( SILENT )?
 10092  26 
             int alt74=2;
 10093  26 
             switch ( input.LA(1) ) {
 10094   
                 case SILENT:
 10095   
                     {
 10096  6 
                     alt74=1;
 10097   
                     }
 10098   
                     break;
 10099   
             }
 10100   
 
 10101  26 
             switch (alt74) {
 10102   
                 case 1 :
 10103   
                     // com\\googlecode\\sparkleg\\Sparql.g:318:15: SILENT
 10104   
                     {
 10105  6 
                     SILENT226=(Token)match(input,SILENT,FOLLOW_SILENT_in_serviceGraphPattern2586);
 10106  6 
                     stream_SILENT.add(SILENT226);
 10107   
 
 10108   
 
 10109   
                     }
 10110   
                     break;
 10111   
 
 10112   
             }
 10113   
 
 10114   
 
 10115  26 
             pushFollow(FOLLOW_varOrIRIref_in_serviceGraphPattern2589);
 10116  26 
             varOrIRIref227=varOrIRIref();
 10117   
 
 10118  26 
             state._fsp--;
 10119   
 
 10120  26 
             stream_varOrIRIref.add(varOrIRIref227.getTree());
 10121   
 
 10122  26 
             pushFollow(FOLLOW_groupGraphPattern_in_serviceGraphPattern2591);
 10123  26 
             groupGraphPattern228=groupGraphPattern();
 10124   
 
 10125  26 
             state._fsp--;
 10126   
 
 10127  26 
             stream_groupGraphPattern.add(groupGraphPattern228.getTree());
 10128   
 
 10129   
             // AST REWRITE
 10130   
             // elements: groupGraphPattern, SERVICE, SILENT, varOrIRIref
 10131   
             // token labels:
 10132   
             // rule labels: retval
 10133   
             // token list labels:
 10134   
             // rule list labels:
 10135   
             // wildcard labels:
 10136  26 
             retval.tree = root_0;
 10137  26 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10138   
 
 10139  26 
             root_0 = (Object)adaptor.nil();
 10140   
             // 318:53: -> ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10141   
             {
 10142   
                 // com\\googlecode\\sparkleg\\Sparql.g:318:56: ^( SERVICE ( SILENT )? varOrIRIref groupGraphPattern )
 10143   
                 {
 10144  26 
                 Object root_1 = (Object)adaptor.nil();
 10145  26 
                 root_1 = (Object)adaptor.becomeRoot(
 10146   
                 stream_SERVICE.nextNode()
 10147   
                 , root_1);
 10148   
 
 10149   
                 // com\\googlecode\\sparkleg\\Sparql.g:318:66: ( SILENT )?
 10150  26 
                 if ( stream_SILENT.hasNext() ) {
 10151  6 
                     adaptor.addChild(root_1,
 10152   
                     stream_SILENT.nextNode()
 10153   
                     );
 10154   
 
 10155   
                 }
 10156  26 
                 stream_SILENT.reset();
 10157   
 
 10158  26 
                 adaptor.addChild(root_1, stream_varOrIRIref.nextTree());
 10159   
 
 10160  26 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10161   
 
 10162  26 
                 adaptor.addChild(root_0, root_1);
 10163   
                 }
 10164   
 
 10165   
             }
 10166   
 
 10167   
 
 10168  26 
             retval.tree = root_0;
 10169   
 
 10170   
             }
 10171   
 
 10172  26 
             retval.stop = input.LT(-1);
 10173   
 
 10174   
 
 10175  26 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10176  26 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10177   
 
 10178   
         }
 10179  0 
         catch (RecognitionException re) {
 10180  0 
             reportError(re);
 10181  0 
             recover(input,re);
 10182  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10183   
 
 10184   
         }
 10185   
 
 10186  0 
         finally {
 10187   
                 // do for sure before leaving
 10188  26 
         }
 10189  26 
         return retval;
 10190   
     }
 10191   
     // $ANTLR end "serviceGraphPattern"
 10192   
 
 10193   
 
 10194  50 
     public static class bind_return extends ParserRuleReturnScope {
 10195   
         Object tree;
 10196  50 
         public Object getTree() { return tree; }
 10197   
     };
 10198   
 
 10199   
 
 10200   
     // $ANTLR start "bind"
 10201   
     // com\\googlecode\\sparkleg\\Sparql.g:321:1: bind : BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) ;
 10202   
     public final SparqlParser.bind_return bind() throws RecognitionException {
 10203  50 
         SparqlParser.bind_return retval = new SparqlParser.bind_return();
 10204  50 
         retval.start = input.LT(1);
 10205   
 
 10206   
 
 10207  50 
         Object root_0 = null;
 10208   
 
 10209  50 
         Token BIND229=null;
 10210  50 
         Token OPEN_BRACE230=null;
 10211  50 
         Token AS232=null;
 10212  50 
         Token CLOSE_BRACE234=null;
 10213  50 
         SparqlParser.expression_return expression231 =null;
 10214   
 
 10215  50 
         SparqlParser.var_return var233 =null;
 10216   
 
 10217   
 
 10218  50 
         Object BIND229_tree=null;
 10219  50 
         Object OPEN_BRACE230_tree=null;
 10220  50 
         Object AS232_tree=null;
 10221  50 
         Object CLOSE_BRACE234_tree=null;
 10222  50 
         RewriteRuleTokenStream stream_AS=new RewriteRuleTokenStream(adaptor,"token AS");
 10223  50 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10224  50 
         RewriteRuleTokenStream stream_BIND=new RewriteRuleTokenStream(adaptor,"token BIND");
 10225  50 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10226  50 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10227  50 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 10228   
         try {
 10229   
             // com\\googlecode\\sparkleg\\Sparql.g:322:5: ( BIND OPEN_BRACE expression AS var CLOSE_BRACE -> ^( BIND expression ^( AS var ) ) )
 10230   
             // com\\googlecode\\sparkleg\\Sparql.g:322:7: BIND OPEN_BRACE expression AS var CLOSE_BRACE
 10231   
             {
 10232  50 
             BIND229=(Token)match(input,BIND,FOLLOW_BIND_in_bind2625);
 10233  50 
             stream_BIND.add(BIND229);
 10234   
 
 10235   
 
 10236  50 
             OPEN_BRACE230=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_bind2627);
 10237  50 
             stream_OPEN_BRACE.add(OPEN_BRACE230);
 10238   
 
 10239   
 
 10240  50 
             pushFollow(FOLLOW_expression_in_bind2629);
 10241  50 
             expression231=expression();
 10242   
 
 10243  50 
             state._fsp--;
 10244   
 
 10245  50 
             stream_expression.add(expression231.getTree());
 10246   
 
 10247  50 
             AS232=(Token)match(input,AS,FOLLOW_AS_in_bind2631);
 10248  50 
             stream_AS.add(AS232);
 10249   
 
 10250   
 
 10251  50 
             pushFollow(FOLLOW_var_in_bind2633);
 10252  50 
             var233=var();
 10253   
 
 10254  50 
             state._fsp--;
 10255   
 
 10256  50 
             stream_var.add(var233.getTree());
 10257   
 
 10258  50 
             CLOSE_BRACE234=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_bind2635);
 10259  50 
             stream_CLOSE_BRACE.add(CLOSE_BRACE234);
 10260   
 
 10261   
 
 10262   
             // AST REWRITE
 10263   
             // elements: expression, var, AS, BIND
 10264   
             // token labels:
 10265   
             // rule labels: retval
 10266   
             // token list labels:
 10267   
             // rule list labels:
 10268   
             // wildcard labels:
 10269  50 
             retval.tree = root_0;
 10270  50 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10271   
 
 10272  50 
             root_0 = (Object)adaptor.nil();
 10273   
             // 322:53: -> ^( BIND expression ^( AS var ) )
 10274   
             {
 10275   
                 // com\\googlecode\\sparkleg\\Sparql.g:322:56: ^( BIND expression ^( AS var ) )
 10276   
                 {
 10277  50 
                 Object root_1 = (Object)adaptor.nil();
 10278  50 
                 root_1 = (Object)adaptor.becomeRoot(
 10279   
                 stream_BIND.nextNode()
 10280   
                 , root_1);
 10281   
 
 10282  50 
                 adaptor.addChild(root_1, stream_expression.nextTree());
 10283   
 
 10284   
                 // com\\googlecode\\sparkleg\\Sparql.g:322:74: ^( AS var )
 10285   
                 {
 10286  50 
                 Object root_2 = (Object)adaptor.nil();
 10287  50 
                 root_2 = (Object)adaptor.becomeRoot(
 10288   
                 stream_AS.nextNode()
 10289   
                 , root_2);
 10290   
 
 10291  50 
                 adaptor.addChild(root_2, stream_var.nextTree());
 10292   
 
 10293  50 
                 adaptor.addChild(root_1, root_2);
 10294   
                 }
 10295   
 
 10296  50 
                 adaptor.addChild(root_0, root_1);
 10297   
                 }
 10298   
 
 10299   
             }
 10300   
 
 10301   
 
 10302  50 
             retval.tree = root_0;
 10303   
 
 10304   
             }
 10305   
 
 10306  50 
             retval.stop = input.LT(-1);
 10307   
 
 10308   
 
 10309  50 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10310  50 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10311   
 
 10312   
         }
 10313  0 
         catch (RecognitionException re) {
 10314  0 
             reportError(re);
 10315  0 
             recover(input,re);
 10316  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10317   
 
 10318   
         }
 10319   
 
 10320  0 
         finally {
 10321   
                 // do for sure before leaving
 10322  50 
         }
 10323  50 
         return retval;
 10324   
     }
 10325   
     // $ANTLR end "bind"
 10326   
 
 10327   
 
 10328  42 
     public static class minusGraphPattern_return extends ParserRuleReturnScope {
 10329   
         Object tree;
 10330  42 
         public Object getTree() { return tree; }
 10331   
     };
 10332   
 
 10333   
 
 10334   
     // $ANTLR start "minusGraphPattern"
 10335   
     // com\\googlecode\\sparkleg\\Sparql.g:325:1: minusGraphPattern : MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) ;
 10336   
     public final SparqlParser.minusGraphPattern_return minusGraphPattern() throws RecognitionException {
 10337  42 
         SparqlParser.minusGraphPattern_return retval = new SparqlParser.minusGraphPattern_return();
 10338  42 
         retval.start = input.LT(1);
 10339   
 
 10340   
 
 10341  42 
         Object root_0 = null;
 10342   
 
 10343  42 
         Token MINUS_KEYWORD235=null;
 10344  42 
         SparqlParser.groupGraphPattern_return groupGraphPattern236 =null;
 10345   
 
 10346   
 
 10347  42 
         Object MINUS_KEYWORD235_tree=null;
 10348  42 
         RewriteRuleTokenStream stream_MINUS_KEYWORD=new RewriteRuleTokenStream(adaptor,"token MINUS_KEYWORD");
 10349  42 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10350   
         try {
 10351   
             // com\\googlecode\\sparkleg\\Sparql.g:326:5: ( MINUS_KEYWORD groupGraphPattern -> ^( MINUS_KEYWORD groupGraphPattern ) )
 10352   
             // com\\googlecode\\sparkleg\\Sparql.g:326:7: MINUS_KEYWORD groupGraphPattern
 10353   
             {
 10354  42 
             MINUS_KEYWORD235=(Token)match(input,MINUS_KEYWORD,FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2672);
 10355  42 
             stream_MINUS_KEYWORD.add(MINUS_KEYWORD235);
 10356   
 
 10357   
 
 10358  42 
             pushFollow(FOLLOW_groupGraphPattern_in_minusGraphPattern2674);
 10359  42 
             groupGraphPattern236=groupGraphPattern();
 10360   
 
 10361  42 
             state._fsp--;
 10362   
 
 10363  42 
             stream_groupGraphPattern.add(groupGraphPattern236.getTree());
 10364   
 
 10365   
             // AST REWRITE
 10366   
             // elements: groupGraphPattern, MINUS_KEYWORD
 10367   
             // token labels:
 10368   
             // rule labels: retval
 10369   
             // token list labels:
 10370   
             // rule list labels:
 10371   
             // wildcard labels:
 10372  42 
             retval.tree = root_0;
 10373  42 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10374   
 
 10375  42 
             root_0 = (Object)adaptor.nil();
 10376   
             // 326:39: -> ^( MINUS_KEYWORD groupGraphPattern )
 10377   
             {
 10378   
                 // com\\googlecode\\sparkleg\\Sparql.g:326:42: ^( MINUS_KEYWORD groupGraphPattern )
 10379   
                 {
 10380  42 
                 Object root_1 = (Object)adaptor.nil();
 10381  42 
                 root_1 = (Object)adaptor.becomeRoot(
 10382   
                 stream_MINUS_KEYWORD.nextNode()
 10383   
                 , root_1);
 10384   
 
 10385  42 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 10386   
 
 10387  42 
                 adaptor.addChild(root_0, root_1);
 10388   
                 }
 10389   
 
 10390   
             }
 10391   
 
 10392   
 
 10393  42 
             retval.tree = root_0;
 10394   
 
 10395   
             }
 10396   
 
 10397  42 
             retval.stop = input.LT(-1);
 10398   
 
 10399   
 
 10400  42 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10401  42 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10402   
 
 10403   
         }
 10404  0 
         catch (RecognitionException re) {
 10405  0 
             reportError(re);
 10406  0 
             recover(input,re);
 10407  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10408   
 
 10409   
         }
 10410   
 
 10411  0 
         finally {
 10412   
                 // do for sure before leaving
 10413  42 
         }
 10414  42 
         return retval;
 10415   
     }
 10416   
     // $ANTLR end "minusGraphPattern"
 10417   
 
 10418   
 
 10419  176 
     public static class groupOrUnionGraphPattern_return extends ParserRuleReturnScope {
 10420   
         Object tree;
 10421  176 
         public Object getTree() { return tree; }
 10422   
     };
 10423   
 
 10424   
 
 10425   
     // $ANTLR start "groupOrUnionGraphPattern"
 10426   
     // com\\googlecode\\sparkleg\\Sparql.g:329:1: groupOrUnionGraphPattern : (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* ;
 10427   
     public final SparqlParser.groupOrUnionGraphPattern_return groupOrUnionGraphPattern() throws RecognitionException {
 10428  176 
         SparqlParser.groupOrUnionGraphPattern_return retval = new SparqlParser.groupOrUnionGraphPattern_return();
 10429  176 
         retval.start = input.LT(1);
 10430   
 
 10431   
 
 10432  176 
         Object root_0 = null;
 10433   
 
 10434  176 
         Token UNION237=null;
 10435  176 
         SparqlParser.groupGraphPattern_return g1 =null;
 10436   
 
 10437  176 
         SparqlParser.groupGraphPattern_return g2 =null;
 10438   
 
 10439   
 
 10440  176 
         Object UNION237_tree=null;
 10441  176 
         RewriteRuleTokenStream stream_UNION=new RewriteRuleTokenStream(adaptor,"token UNION");
 10442  176 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 10443   
         try {
 10444   
             // com\\googlecode\\sparkleg\\Sparql.g:330:5: ( (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )* )
 10445   
             // com\\googlecode\\sparkleg\\Sparql.g:330:7: (g1= groupGraphPattern -> $g1) ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10446   
             {
 10447   
             // com\\googlecode\\sparkleg\\Sparql.g:330:7: (g1= groupGraphPattern -> $g1)
 10448   
             // com\\googlecode\\sparkleg\\Sparql.g:330:8: g1= groupGraphPattern
 10449   
             {
 10450  176 
             pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2702);
 10451  176 
             g1=groupGraphPattern();
 10452   
 
 10453  176 
             state._fsp--;
 10454   
 
 10455  176 
             stream_groupGraphPattern.add(g1.getTree());
 10456   
 
 10457   
             // AST REWRITE
 10458   
             // elements: g1
 10459   
             // token labels:
 10460   
             // rule labels: retval, g1
 10461   
             // token list labels:
 10462   
             // rule list labels:
 10463   
             // wildcard labels:
 10464  176 
             retval.tree = root_0;
 10465  176 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10466  176 
             RewriteRuleSubtreeStream stream_g1=new RewriteRuleSubtreeStream(adaptor,"rule g1",g1!=null?g1.tree:null);
 10467   
 
 10468  176 
             root_0 = (Object)adaptor.nil();
 10469   
             // 330:28: -> $g1
 10470   
             {
 10471  176 
                 adaptor.addChild(root_0, stream_g1.nextTree());
 10472   
 
 10473   
             }
 10474   
 
 10475   
 
 10476  176 
             retval.tree = root_0;
 10477   
 
 10478   
             }
 10479   
 
 10480   
 
 10481   
             // com\\googlecode\\sparkleg\\Sparql.g:330:35: ( ( UNION g2= groupGraphPattern ) -> ^( UNION $groupOrUnionGraphPattern $g2) )*
 10482   
             loop75:
 10483   
             do {
 10484  272 
                 int alt75=2;
 10485  272 
                 switch ( input.LA(1) ) {
 10486   
                 case UNION:
 10487   
                     {
 10488  96 
                     alt75=1;
 10489   
                     }
 10490   
                     break;
 10491   
 
 10492   
                 }
 10493   
 
 10494  272 
                 switch (alt75) {
 10495   
                     case 1 :
 10496   
                         // com\\googlecode\\sparkleg\\Sparql.g:330:36: ( UNION g2= groupGraphPattern )
 10497   
                         {
 10498   
                         // com\\googlecode\\sparkleg\\Sparql.g:330:36: ( UNION g2= groupGraphPattern )
 10499   
                         // com\\googlecode\\sparkleg\\Sparql.g:330:37: UNION g2= groupGraphPattern
 10500   
                         {
 10501  96 
                         UNION237=(Token)match(input,UNION,FOLLOW_UNION_in_groupOrUnionGraphPattern2710);
 10502  96 
                         stream_UNION.add(UNION237);
 10503   
 
 10504   
 
 10505  96 
                         pushFollow(FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2714);
 10506  96 
                         g2=groupGraphPattern();
 10507   
 
 10508  96 
                         state._fsp--;
 10509   
 
 10510  96 
                         stream_groupGraphPattern.add(g2.getTree());
 10511   
 
 10512   
                         }
 10513   
 
 10514   
 
 10515   
                         // AST REWRITE
 10516   
                         // elements: g2, UNION, groupOrUnionGraphPattern
 10517   
                         // token labels:
 10518   
                         // rule labels: retval, g2
 10519   
                         // token list labels:
 10520   
                         // rule list labels:
 10521   
                         // wildcard labels:
 10522  96 
                         retval.tree = root_0;
 10523  96 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10524  96 
                         RewriteRuleSubtreeStream stream_g2=new RewriteRuleSubtreeStream(adaptor,"rule g2",g2!=null?g2.tree:null);
 10525   
 
 10526  96 
                         root_0 = (Object)adaptor.nil();
 10527   
                         // 330:65: -> ^( UNION $groupOrUnionGraphPattern $g2)
 10528   
                         {
 10529   
                             // com\\googlecode\\sparkleg\\Sparql.g:330:68: ^( UNION $groupOrUnionGraphPattern $g2)
 10530   
                             {
 10531  96 
                             Object root_1 = (Object)adaptor.nil();
 10532  96 
                             root_1 = (Object)adaptor.becomeRoot(
 10533   
                             stream_UNION.nextNode()
 10534   
                             , root_1);
 10535   
 
 10536  96 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 10537   
 
 10538  96 
                             adaptor.addChild(root_1, stream_g2.nextTree());
 10539   
 
 10540  96 
                             adaptor.addChild(root_0, root_1);
 10541   
                             }
 10542   
 
 10543   
                         }
 10544   
 
 10545   
 
 10546  96 
                         retval.tree = root_0;
 10547   
 
 10548   
                         }
 10549  96 
                         break;
 10550   
 
 10551   
                     default :
 10552  176 
                         break loop75;
 10553   
                 }
 10554  96 
             } while (true);
 10555   
 
 10556   
 
 10557   
             }
 10558   
 
 10559  176 
             retval.stop = input.LT(-1);
 10560   
 
 10561   
 
 10562  176 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10563  176 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10564   
 
 10565   
         }
 10566  0 
         catch (RecognitionException re) {
 10567  0 
             reportError(re);
 10568  0 
             recover(input,re);
 10569  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10570   
 
 10571   
         }
 10572   
 
 10573  0 
         finally {
 10574   
                 // do for sure before leaving
 10575  176 
         }
 10576  176 
         return retval;
 10577   
     }
 10578   
     // $ANTLR end "groupOrUnionGraphPattern"
 10579   
 
 10580   
 
 10581  584 
     public static class filter_return extends ParserRuleReturnScope {
 10582   
         Object tree;
 10583  584 
         public Object getTree() { return tree; }
 10584   
     };
 10585   
 
 10586   
 
 10587   
     // $ANTLR start "filter"
 10588   
     // com\\googlecode\\sparkleg\\Sparql.g:333:1: filter : FILTER constraint -> ^( FILTER constraint ) ;
 10589   
     public final SparqlParser.filter_return filter() throws RecognitionException {
 10590  584 
         SparqlParser.filter_return retval = new SparqlParser.filter_return();
 10591  584 
         retval.start = input.LT(1);
 10592   
 
 10593   
 
 10594  584 
         Object root_0 = null;
 10595   
 
 10596  584 
         Token FILTER238=null;
 10597  584 
         SparqlParser.constraint_return constraint239 =null;
 10598   
 
 10599   
 
 10600  584 
         Object FILTER238_tree=null;
 10601  584 
         RewriteRuleTokenStream stream_FILTER=new RewriteRuleTokenStream(adaptor,"token FILTER");
 10602  584 
         RewriteRuleSubtreeStream stream_constraint=new RewriteRuleSubtreeStream(adaptor,"rule constraint");
 10603   
         try {
 10604   
             // com\\googlecode\\sparkleg\\Sparql.g:334:5: ( FILTER constraint -> ^( FILTER constraint ) )
 10605   
             // com\\googlecode\\sparkleg\\Sparql.g:334:7: FILTER constraint
 10606   
             {
 10607  584 
             FILTER238=(Token)match(input,FILTER,FOLLOW_FILTER_in_filter2746);
 10608  584 
             stream_FILTER.add(FILTER238);
 10609   
 
 10610   
 
 10611  584 
             pushFollow(FOLLOW_constraint_in_filter2748);
 10612  584 
             constraint239=constraint();
 10613   
 
 10614  584 
             state._fsp--;
 10615   
 
 10616  584 
             stream_constraint.add(constraint239.getTree());
 10617   
 
 10618   
             // AST REWRITE
 10619   
             // elements: constraint, FILTER
 10620   
             // token labels:
 10621   
             // rule labels: retval
 10622   
             // token list labels:
 10623   
             // rule list labels:
 10624   
             // wildcard labels:
 10625  584 
             retval.tree = root_0;
 10626  584 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10627   
 
 10628  584 
             root_0 = (Object)adaptor.nil();
 10629   
             // 334:25: -> ^( FILTER constraint )
 10630   
             {
 10631   
                 // com\\googlecode\\sparkleg\\Sparql.g:334:28: ^( FILTER constraint )
 10632   
                 {
 10633  584 
                 Object root_1 = (Object)adaptor.nil();
 10634  584 
                 root_1 = (Object)adaptor.becomeRoot(
 10635   
                 stream_FILTER.nextNode()
 10636   
                 , root_1);
 10637   
 
 10638  584 
                 adaptor.addChild(root_1, stream_constraint.nextTree());
 10639   
 
 10640  584 
                 adaptor.addChild(root_0, root_1);
 10641   
                 }
 10642   
 
 10643   
             }
 10644   
 
 10645   
 
 10646  584 
             retval.tree = root_0;
 10647   
 
 10648   
             }
 10649   
 
 10650  584 
             retval.stop = input.LT(-1);
 10651   
 
 10652   
 
 10653  584 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10654  584 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10655   
 
 10656   
         }
 10657  0 
         catch (RecognitionException re) {
 10658  0 
             reportError(re);
 10659  0 
             recover(input,re);
 10660  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10661   
 
 10662   
         }
 10663   
 
 10664  0 
         finally {
 10665   
                 // do for sure before leaving
 10666  584 
         }
 10667  584 
         return retval;
 10668   
     }
 10669   
     // $ANTLR end "filter"
 10670   
 
 10671   
 
 10672  612 
     public static class constraint_return extends ParserRuleReturnScope {
 10673   
         Object tree;
 10674  612 
         public Object getTree() { return tree; }
 10675   
     };
 10676   
 
 10677   
 
 10678   
     // $ANTLR start "constraint"
 10679   
     // com\\googlecode\\sparkleg\\Sparql.g:337:1: constraint : ( brackettedExpression | builtInCall | functionCall );
 10680   
     public final SparqlParser.constraint_return constraint() throws RecognitionException {
 10681  612 
         SparqlParser.constraint_return retval = new SparqlParser.constraint_return();
 10682  612 
         retval.start = input.LT(1);
 10683   
 
 10684   
 
 10685  612 
         Object root_0 = null;
 10686   
 
 10687  612 
         SparqlParser.brackettedExpression_return brackettedExpression240 =null;
 10688   
 
 10689  612 
         SparqlParser.builtInCall_return builtInCall241 =null;
 10690   
 
 10691  612 
         SparqlParser.functionCall_return functionCall242 =null;
 10692   
 
 10693   
 
 10694   
 
 10695   
         try {
 10696   
             // com\\googlecode\\sparkleg\\Sparql.g:338:5: ( brackettedExpression | builtInCall | functionCall )
 10697  612 
             int alt76=3;
 10698  612 
             switch ( input.LA(1) ) {
 10699   
             case OPEN_BRACE:
 10700   
                 {
 10701  446 
                 alt76=1;
 10702   
                 }
 10703  446 
                 break;
 10704   
             case ABS:
 10705   
             case BNODE:
 10706   
             case BOUND:
 10707   
             case CEIL:
 10708   
             case COALESCE:
 10709   
             case CONCAT:
 10710   
             case CONTAINS:
 10711   
             case DATATYPE:
 10712   
             case DAY:
 10713   
             case ENCODE_FOR_URI:
 10714   
             case EXISTS:
 10715   
             case FLOOR:
 10716   
             case HOURS:
 10717   
             case IF:
 10718   
             case IRI:
 10719   
             case ISBLANK:
 10720   
             case ISIRI:
 10721   
             case ISLITERAL:
 10722   
             case ISNUMERIC:
 10723   
             case ISURI:
 10724   
             case LANG:
 10725   
             case LANGMATCHES:
 10726   
             case LCASE:
 10727   
             case MD5:
 10728   
             case MINUTES:
 10729   
             case MONTH:
 10730   
             case NOT:
 10731   
             case NOW:
 10732   
             case RAND:
 10733   
             case REGEX:
 10734   
             case REPLACE:
 10735   
             case ROUND:
 10736   
             case SAMETERM:
 10737   
             case SECONDS:
 10738   
             case SHA1:
 10739   
             case SHA224:
 10740   
             case SHA256:
 10741   
             case SHA384:
 10742   
             case SHA512:
 10743   
             case STR:
 10744   
             case STRAFTER:
 10745   
             case STRBEFORE:
 10746   
             case STRDT:
 10747   
             case STRENDS:
 10748   
             case STRLANG:
 10749   
             case STRLEN:
 10750   
             case STRSTARTS:
 10751   
             case SUBSTR:
 10752   
             case TIMEZONE:
 10753   
             case TZ:
 10754   
             case UCASE:
 10755   
             case URI:
 10756   
             case YEAR:
 10757   
                 {
 10758  158 
                 alt76=2;
 10759   
                 }
 10760  158 
                 break;
 10761   
             case IRI_REF:
 10762   
             case PNAME_LN:
 10763   
             case PNAME_NS:
 10764   
                 {
 10765  8 
                 alt76=3;
 10766   
                 }
 10767  8 
                 break;
 10768   
             default:
 10769  0 
                 NoViableAltException nvae =
 10770   
                     new NoViableAltException("", 76, 0, input);
 10771   
 
 10772  0 
                 throw nvae;
 10773   
 
 10774   
             }
 10775   
 
 10776  612 
             switch (alt76) {
 10777   
                 case 1 :
 10778   
                     // com\\googlecode\\sparkleg\\Sparql.g:338:7: brackettedExpression
 10779   
                     {
 10780  446 
                     root_0 = (Object)adaptor.nil();
 10781   
 
 10782   
 
 10783  446 
                     pushFollow(FOLLOW_brackettedExpression_in_constraint2773);
 10784  446 
                     brackettedExpression240=brackettedExpression();
 10785   
 
 10786  446 
                     state._fsp--;
 10787   
 
 10788  446 
                     adaptor.addChild(root_0, brackettedExpression240.getTree());
 10789   
 
 10790   
                     }
 10791  446 
                     break;
 10792   
                 case 2 :
 10793   
                     // com\\googlecode\\sparkleg\\Sparql.g:339:7: builtInCall
 10794   
                     {
 10795  158 
                     root_0 = (Object)adaptor.nil();
 10796   
 
 10797   
 
 10798  158 
                     pushFollow(FOLLOW_builtInCall_in_constraint2781);
 10799  158 
                     builtInCall241=builtInCall();
 10800   
 
 10801  158 
                     state._fsp--;
 10802   
 
 10803  158 
                     adaptor.addChild(root_0, builtInCall241.getTree());
 10804   
 
 10805   
                     }
 10806  158 
                     break;
 10807   
                 case 3 :
 10808   
                     // com\\googlecode\\sparkleg\\Sparql.g:340:7: functionCall
 10809   
                     {
 10810  8 
                     root_0 = (Object)adaptor.nil();
 10811   
 
 10812   
 
 10813  8 
                     pushFollow(FOLLOW_functionCall_in_constraint2789);
 10814  8 
                     functionCall242=functionCall();
 10815   
 
 10816  8 
                     state._fsp--;
 10817   
 
 10818  8 
                     adaptor.addChild(root_0, functionCall242.getTree());
 10819   
 
 10820   
                     }
 10821   
                     break;
 10822   
 
 10823   
             }
 10824  612 
             retval.stop = input.LT(-1);
 10825   
 
 10826   
 
 10827  612 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10828  612 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10829   
 
 10830   
         }
 10831  0 
         catch (RecognitionException re) {
 10832  0 
             reportError(re);
 10833  0 
             recover(input,re);
 10834  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10835   
 
 10836   
         }
 10837   
 
 10838  0 
         finally {
 10839   
                 // do for sure before leaving
 10840  612 
         }
 10841  612 
         return retval;
 10842   
     }
 10843   
     // $ANTLR end "constraint"
 10844   
 
 10845   
 
 10846  8 
     public static class functionCall_return extends ParserRuleReturnScope {
 10847   
         Object tree;
 10848  8 
         public Object getTree() { return tree; }
 10849   
     };
 10850   
 
 10851   
 
 10852   
     // $ANTLR start "functionCall"
 10853   
     // com\\googlecode\\sparkleg\\Sparql.g:343:1: functionCall : iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) ;
 10854   
     public final SparqlParser.functionCall_return functionCall() throws RecognitionException {
 10855  8 
         SparqlParser.functionCall_return retval = new SparqlParser.functionCall_return();
 10856  8 
         retval.start = input.LT(1);
 10857   
 
 10858   
 
 10859  8 
         Object root_0 = null;
 10860   
 
 10861  8 
         SparqlParser.iriRef_return iriRef243 =null;
 10862   
 
 10863  8 
         SparqlParser.argList_return argList244 =null;
 10864   
 
 10865   
 
 10866  8 
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 10867  8 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 10868   
         try {
 10869   
             // com\\googlecode\\sparkleg\\Sparql.g:344:5: ( iriRef argList -> ^( FUNCTION iriRef ^( ARG_LIST argList ) ) )
 10870   
             // com\\googlecode\\sparkleg\\Sparql.g:344:7: iriRef argList
 10871   
             {
 10872  8 
             pushFollow(FOLLOW_iriRef_in_functionCall2806);
 10873  8 
             iriRef243=iriRef();
 10874   
 
 10875  8 
             state._fsp--;
 10876   
 
 10877  8 
             stream_iriRef.add(iriRef243.getTree());
 10878   
 
 10879  8 
             pushFollow(FOLLOW_argList_in_functionCall2808);
 10880  8 
             argList244=argList();
 10881   
 
 10882  8 
             state._fsp--;
 10883   
 
 10884  8 
             stream_argList.add(argList244.getTree());
 10885   
 
 10886   
             // AST REWRITE
 10887   
             // elements: iriRef, argList
 10888   
             // token labels:
 10889   
             // rule labels: retval
 10890   
             // token list labels:
 10891   
             // rule list labels:
 10892   
             // wildcard labels:
 10893  8 
             retval.tree = root_0;
 10894  8 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 10895   
 
 10896  8 
             root_0 = (Object)adaptor.nil();
 10897   
             // 344:22: -> ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10898   
             {
 10899   
                 // com\\googlecode\\sparkleg\\Sparql.g:344:25: ^( FUNCTION iriRef ^( ARG_LIST argList ) )
 10900   
                 {
 10901  8 
                 Object root_1 = (Object)adaptor.nil();
 10902  8 
                 root_1 = (Object)adaptor.becomeRoot(
 10903   
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 10904   
                 , root_1);
 10905   
 
 10906  8 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 10907   
 
 10908   
                 // com\\googlecode\\sparkleg\\Sparql.g:344:43: ^( ARG_LIST argList )
 10909   
                 {
 10910  8 
                 Object root_2 = (Object)adaptor.nil();
 10911  8 
                 root_2 = (Object)adaptor.becomeRoot(
 10912   
                 (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 10913   
                 , root_2);
 10914   
 
 10915  8 
                 adaptor.addChild(root_2, stream_argList.nextTree());
 10916   
 
 10917  8 
                 adaptor.addChild(root_1, root_2);
 10918   
                 }
 10919   
 
 10920  8 
                 adaptor.addChild(root_0, root_1);
 10921   
                 }
 10922   
 
 10923   
             }
 10924   
 
 10925   
 
 10926  8 
             retval.tree = root_0;
 10927   
 
 10928   
             }
 10929   
 
 10930  8 
             retval.stop = input.LT(-1);
 10931   
 
 10932   
 
 10933  8 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 10934  8 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 10935   
 
 10936   
         }
 10937  0 
         catch (RecognitionException re) {
 10938  0 
             reportError(re);
 10939  0 
             recover(input,re);
 10940  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 10941   
 
 10942   
         }
 10943   
 
 10944  0 
         finally {
 10945   
                 // do for sure before leaving
 10946  8 
         }
 10947  8 
         return retval;
 10948   
     }
 10949   
     // $ANTLR end "functionCall"
 10950   
 
 10951   
 
 10952  121 
     public static class argList_return extends ParserRuleReturnScope {
 10953   
         Object tree;
 10954  121 
         public Object getTree() { return tree; }
 10955   
     };
 10956   
 
 10957   
 
 10958   
     // $ANTLR start "argList"
 10959   
     // com\\googlecode\\sparkleg\\Sparql.g:347:1: argList : ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* );
 10960   
     public final SparqlParser.argList_return argList() throws RecognitionException {
 10961  121 
         SparqlParser.argList_return retval = new SparqlParser.argList_return();
 10962  121 
         retval.start = input.LT(1);
 10963   
 
 10964   
 
 10965  121 
         Object root_0 = null;
 10966   
 
 10967  121 
         Token OPEN_BRACE246=null;
 10968  121 
         Token DISTINCT247=null;
 10969  121 
         Token COMMA249=null;
 10970  121 
         Token CLOSE_BRACE251=null;
 10971  121 
         SparqlParser.nil_return nil245 =null;
 10972   
 
 10973  121 
         SparqlParser.expression_return expression248 =null;
 10974   
 
 10975  121 
         SparqlParser.expression_return expression250 =null;
 10976   
 
 10977   
 
 10978  121 
         Object OPEN_BRACE246_tree=null;
 10979  121 
         Object DISTINCT247_tree=null;
 10980  121 
         Object COMMA249_tree=null;
 10981  121 
         Object CLOSE_BRACE251_tree=null;
 10982  121 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 10983  121 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 10984  121 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 10985  121 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 10986  121 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 10987  121 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 10988   
         try {
 10989   
             // com\\googlecode\\sparkleg\\Sparql.g:348:5: ( nil -> nil | OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE -> ( DISTINCT )? ( expression )* )
 10990  121 
             int alt79=2;
 10991  121 
             switch ( input.LA(1) ) {
 10992   
             case OPEN_BRACE:
 10993   
                 {
 10994  121 
                 switch ( input.LA(2) ) {
 10995   
                 case CLOSE_BRACE:
 10996   
                     {
 10997  71 
                     alt79=1;
 10998   
                     }
 10999  71 
                     break;
 11000   
                 case ABS:
 11001   
                 case AVG:
 11002   
                 case BNODE:
 11003   
                 case BOUND:
 11004   
                 case CEIL:
 11005   
                 case COALESCE:
 11006   
                 case CONCAT:
 11007   
                 case CONTAINS:
 11008   
                 case COUNT:
 11009   
                 case DATATYPE:
 11010   
                 case DAY:
 11011   
                 case DECIMAL:
 11012   
                 case DECIMAL_NEGATIVE:
 11013   
                 case DECIMAL_POSITIVE:
 11014   
                 case DISTINCT:
 11015   
                 case DOUBLE:
 11016   
                 case DOUBLE_NEGATIVE:
 11017   
                 case DOUBLE_POSITIVE:
 11018   
                 case ENCODE_FOR_URI:
 11019   
                 case EXISTS:
 11020   
                 case FALSE:
 11021   
                 case FLOOR:
 11022   
                 case GROUP_CONCAT:
 11023   
                 case HOURS:
 11024   
                 case IF:
 11025   
                 case INTEGER:
 11026   
                 case INTEGER_NEGATIVE:
 11027   
                 case INTEGER_POSITIVE:
 11028   
                 case IRI:
 11029   
                 case IRI_REF:
 11030   
                 case ISBLANK:
 11031   
                 case ISIRI:
 11032   
                 case ISLITERAL:
 11033   
                 case ISNUMERIC:
 11034   
                 case ISURI:
 11035   
                 case LANG:
 11036   
                 case LANGMATCHES:
 11037   
                 case LCASE:
 11038   
                 case MAX:
 11039   
                 case MD5:
 11040   
                 case MIN:
 11041   
                 case MINUS:
 11042   
                 case MINUTES:
 11043   
                 case MONTH:
 11044   
                 case NEGATION:
 11045   
                 case NOT:
 11046   
                 case NOW:
 11047   
                 case OPEN_BRACE:
 11048   
                 case PLUS:
 11049   
                 case PNAME_LN:
 11050   
                 case PNAME_NS:
 11051   
                 case RAND:
 11052   
                 case REGEX:
 11053   
                 case REPLACE:
 11054   
                 case ROUND:
 11055   
                 case SAMETERM:
 11056   
                 case SAMPLE:
 11057   
                 case SECONDS:
 11058   
                 case SHA1:
 11059   
                 case SHA224:
 11060   
                 case SHA256:
 11061   
                 case SHA384:
 11062   
                 case SHA512:
 11063   
                 case STR:
 11064   
                 case STRAFTER:
 11065   
                 case STRBEFORE:
 11066   
                 case STRDT:
 11067   
                 case STRENDS:
 11068   
                 case STRING_LITERAL1:
 11069   
                 case STRING_LITERAL2:
 11070   
                 case STRING_LITERAL_LONG1:
 11071   
                 case STRING_LITERAL_LONG2:
 11072   
                 case STRLANG:
 11073   
                 case STRLEN:
 11074   
                 case STRSTARTS:
 11075   
                 case SUBSTR:
 11076   
                 case SUM:
 11077   
                 case TIMEZONE:
 11078   
                 case TRUE:
 11079   
                 case TZ:
 11080   
                 case UCASE:
 11081   
                 case URI:
 11082   
                 case VAR1:
 11083   
                 case VAR2:
 11084   
                 case YEAR:
 11085   
                     {
 11086  50 
                     alt79=2;
 11087   
                     }
 11088  50 
                     break;
 11089   
                 default:
 11090  0 
                     NoViableAltException nvae =
 11091   
                         new NoViableAltException("", 79, 1, input);
 11092   
 
 11093  0 
                     throw nvae;
 11094   
 
 11095   
                 }
 11096   
 
 11097   
                 }
 11098  121 
                 break;
 11099   
             default:
 11100  0 
                 NoViableAltException nvae =
 11101   
                     new NoViableAltException("", 79, 0, input);
 11102   
 
 11103  0 
                 throw nvae;
 11104   
 
 11105   
             }
 11106   
 
 11107  121 
             switch (alt79) {
 11108   
                 case 1 :
 11109   
                     // com\\googlecode\\sparkleg\\Sparql.g:348:7: nil
 11110   
                     {
 11111  71 
                     pushFollow(FOLLOW_nil_in_argList2839);
 11112  71 
                     nil245=nil();
 11113   
 
 11114  71 
                     state._fsp--;
 11115   
 
 11116  71 
                     stream_nil.add(nil245.getTree());
 11117   
 
 11118   
                     // AST REWRITE
 11119   
                     // elements: nil
 11120   
                     // token labels:
 11121   
                     // rule labels: retval
 11122   
                     // token list labels:
 11123   
                     // rule list labels:
 11124   
                     // wildcard labels:
 11125  71 
                     retval.tree = root_0;
 11126  71 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11127   
 
 11128  71 
                     root_0 = (Object)adaptor.nil();
 11129   
                     // 348:11: -> nil
 11130   
                     {
 11131  71 
                         adaptor.addChild(root_0, stream_nil.nextTree());
 11132   
 
 11133   
                     }
 11134   
 
 11135   
 
 11136  71 
                     retval.tree = root_0;
 11137   
 
 11138   
                     }
 11139  71 
                     break;
 11140   
                 case 2 :
 11141   
                     // com\\googlecode\\sparkleg\\Sparql.g:349:7: OPEN_BRACE ( DISTINCT )? expression ( COMMA expression )* CLOSE_BRACE
 11142   
                     {
 11143  50 
                     OPEN_BRACE246=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_argList2851);
 11144  50 
                     stream_OPEN_BRACE.add(OPEN_BRACE246);
 11145   
 
 11146   
 
 11147   
                     // com\\googlecode\\sparkleg\\Sparql.g:349:18: ( DISTINCT )?
 11148  50 
                     int alt77=2;
 11149  50 
                     switch ( input.LA(1) ) {
 11150   
                         case DISTINCT:
 11151   
                             {
 11152  0 
                             alt77=1;
 11153   
                             }
 11154   
                             break;
 11155   
                     }
 11156   
 
 11157  50 
                     switch (alt77) {
 11158   
                         case 1 :
 11159   
                             // com\\googlecode\\sparkleg\\Sparql.g:349:18: DISTINCT
 11160   
                             {
 11161  0 
                             DISTINCT247=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_argList2853);
 11162  0 
                             stream_DISTINCT.add(DISTINCT247);
 11163   
 
 11164   
 
 11165   
                             }
 11166   
                             break;
 11167   
 
 11168   
                     }
 11169   
 
 11170   
 
 11171  50 
                     pushFollow(FOLLOW_expression_in_argList2856);
 11172  50 
                     expression248=expression();
 11173   
 
 11174  50 
                     state._fsp--;
 11175   
 
 11176  50 
                     stream_expression.add(expression248.getTree());
 11177   
 
 11178   
                     // com\\googlecode\\sparkleg\\Sparql.g:349:39: ( COMMA expression )*
 11179   
                     loop78:
 11180   
                     do {
 11181  68 
                         int alt78=2;
 11182  68 
                         switch ( input.LA(1) ) {
 11183   
                         case COMMA:
 11184   
                             {
 11185  18 
                             alt78=1;
 11186   
                             }
 11187   
                             break;
 11188   
 
 11189   
                         }
 11190   
 
 11191  68 
                         switch (alt78) {
 11192   
                             case 1 :
 11193   
                                 // com\\googlecode\\sparkleg\\Sparql.g:349:40: COMMA expression
 11194   
                                 {
 11195  18 
                                 COMMA249=(Token)match(input,COMMA,FOLLOW_COMMA_in_argList2859);
 11196  18 
                                 stream_COMMA.add(COMMA249);
 11197   
 
 11198   
 
 11199  18 
                                 pushFollow(FOLLOW_expression_in_argList2861);
 11200  18 
                                 expression250=expression();
 11201   
 
 11202  18 
                                 state._fsp--;
 11203   
 
 11204  18 
                                 stream_expression.add(expression250.getTree());
 11205   
 
 11206   
                                 }
 11207  18 
                                 break;
 11208   
 
 11209   
                             default :
 11210  50 
                                 break loop78;
 11211   
                         }
 11212  18 
                     } while (true);
 11213   
 
 11214   
 
 11215  50 
                     CLOSE_BRACE251=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_argList2865);
 11216  50 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE251);
 11217   
 
 11218   
 
 11219   
                     // AST REWRITE
 11220   
                     // elements: expression, DISTINCT
 11221   
                     // token labels:
 11222   
                     // rule labels: retval
 11223   
                     // token list labels:
 11224   
                     // rule list labels:
 11225   
                     // wildcard labels:
 11226  50 
                     retval.tree = root_0;
 11227  50 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11228   
 
 11229  50 
                     root_0 = (Object)adaptor.nil();
 11230   
                     // 349:71: -> ( DISTINCT )? ( expression )*
 11231   
                     {
 11232   
                         // com\\googlecode\\sparkleg\\Sparql.g:349:74: ( DISTINCT )?
 11233  50 
                         if ( stream_DISTINCT.hasNext() ) {
 11234  0 
                             adaptor.addChild(root_0,
 11235   
                             stream_DISTINCT.nextNode()
 11236   
                             );
 11237   
 
 11238   
                         }
 11239  50 
                         stream_DISTINCT.reset();
 11240   
 
 11241   
                         // com\\googlecode\\sparkleg\\Sparql.g:349:84: ( expression )*
 11242  118 
                         while ( stream_expression.hasNext() ) {
 11243  68 
                             adaptor.addChild(root_0, stream_expression.nextTree());
 11244   
 
 11245   
                         }
 11246  50 
                         stream_expression.reset();
 11247   
 
 11248   
                     }
 11249   
 
 11250   
 
 11251  50 
                     retval.tree = root_0;
 11252   
 
 11253   
                     }
 11254   
                     break;
 11255   
 
 11256   
             }
 11257  121 
             retval.stop = input.LT(-1);
 11258   
 
 11259   
 
 11260  121 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11261  121 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11262   
 
 11263   
         }
 11264  0 
         catch (RecognitionException re) {
 11265  0 
             reportError(re);
 11266  0 
             recover(input,re);
 11267  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11268   
 
 11269   
         }
 11270   
 
 11271  0 
         finally {
 11272   
                 // do for sure before leaving
 11273  121 
         }
 11274  121 
         return retval;
 11275   
     }
 11276   
     // $ANTLR end "argList"
 11277   
 
 11278   
 
 11279  30 
     public static class expressionList_return extends ParserRuleReturnScope {
 11280   
         Object tree;
 11281  30 
         public Object getTree() { return tree; }
 11282   
     };
 11283   
 
 11284   
 
 11285   
     // $ANTLR start "expressionList"
 11286   
     // com\\googlecode\\sparkleg\\Sparql.g:352:1: expressionList : ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) ;
 11287   
     public final SparqlParser.expressionList_return expressionList() throws RecognitionException {
 11288  30 
         SparqlParser.expressionList_return retval = new SparqlParser.expressionList_return();
 11289  30 
         retval.start = input.LT(1);
 11290   
 
 11291   
 
 11292  30 
         Object root_0 = null;
 11293   
 
 11294  30 
         Token OPEN_BRACE253=null;
 11295  30 
         Token COMMA255=null;
 11296  30 
         Token CLOSE_BRACE257=null;
 11297  30 
         SparqlParser.nil_return nil252 =null;
 11298   
 
 11299  30 
         SparqlParser.expression_return expression254 =null;
 11300   
 
 11301  30 
         SparqlParser.expression_return expression256 =null;
 11302   
 
 11303   
 
 11304  30 
         Object OPEN_BRACE253_tree=null;
 11305  30 
         Object COMMA255_tree=null;
 11306  30 
         Object CLOSE_BRACE257_tree=null;
 11307  30 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 11308  30 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 11309  30 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 11310  30 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 11311  30 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 11312   
         try {
 11313   
             // com\\googlecode\\sparkleg\\Sparql.g:353:5: ( ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE ) -> ^( EXPRESSION_LIST ( nil )* ( expression )* ) )
 11314   
             // com\\googlecode\\sparkleg\\Sparql.g:353:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11315   
             {
 11316   
             // com\\googlecode\\sparkleg\\Sparql.g:353:7: ( nil | OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE )
 11317  30 
             int alt81=2;
 11318  30 
             switch ( input.LA(1) ) {
 11319   
             case OPEN_BRACE:
 11320   
                 {
 11321  30 
                 switch ( input.LA(2) ) {
 11322   
                 case CLOSE_BRACE:
 11323   
                     {
 11324  2 
                     alt81=1;
 11325   
                     }
 11326  2 
                     break;
 11327   
                 case ABS:
 11328   
                 case AVG:
 11329   
                 case BNODE:
 11330   
                 case BOUND:
 11331   
                 case CEIL:
 11332   
                 case COALESCE:
 11333   
                 case CONCAT:
 11334   
                 case CONTAINS:
 11335   
                 case COUNT:
 11336   
                 case DATATYPE:
 11337   
                 case DAY:
 11338   
                 case DECIMAL:
 11339   
                 case DECIMAL_NEGATIVE:
 11340   
                 case DECIMAL_POSITIVE:
 11341   
                 case DOUBLE:
 11342   
                 case DOUBLE_NEGATIVE:
 11343   
                 case DOUBLE_POSITIVE:
 11344   
                 case ENCODE_FOR_URI:
 11345   
                 case EXISTS:
 11346   
                 case FALSE:
 11347   
                 case FLOOR:
 11348   
                 case GROUP_CONCAT:
 11349   
                 case HOURS:
 11350   
                 case IF:
 11351   
                 case INTEGER:
 11352   
                 case INTEGER_NEGATIVE:
 11353   
                 case INTEGER_POSITIVE:
 11354   
                 case IRI:
 11355   
                 case IRI_REF:
 11356   
                 case ISBLANK:
 11357   
                 case ISIRI:
 11358   
                 case ISLITERAL:
 11359   
                 case ISNUMERIC:
 11360   
                 case ISURI:
 11361   
                 case LANG:
 11362   
                 case LANGMATCHES:
 11363   
                 case LCASE:
 11364   
                 case MAX:
 11365   
                 case MD5:
 11366   
                 case MIN:
 11367   
                 case MINUS:
 11368   
                 case MINUTES:
 11369   
                 case MONTH:
 11370   
                 case NEGATION:
 11371   
                 case NOT:
 11372   
                 case NOW:
 11373   
                 case OPEN_BRACE:
 11374   
                 case PLUS:
 11375   
                 case PNAME_LN:
 11376   
                 case PNAME_NS:
 11377   
                 case RAND:
 11378   
                 case REGEX:
 11379   
                 case REPLACE:
 11380   
                 case ROUND:
 11381   
                 case SAMETERM:
 11382   
                 case SAMPLE:
 11383   
                 case SECONDS:
 11384   
                 case SHA1:
 11385   
                 case SHA224:
 11386   
                 case SHA256:
 11387   
                 case SHA384:
 11388   
                 case SHA512:
 11389   
                 case STR:
 11390   
                 case STRAFTER:
 11391   
                 case STRBEFORE:
 11392   
                 case STRDT:
 11393   
                 case STRENDS:
 11394   
                 case STRING_LITERAL1:
 11395   
                 case STRING_LITERAL2:
 11396   
                 case STRING_LITERAL_LONG1:
 11397   
                 case STRING_LITERAL_LONG2:
 11398   
                 case STRLANG:
 11399   
                 case STRLEN:
 11400   
                 case STRSTARTS:
 11401   
                 case SUBSTR:
 11402   
                 case SUM:
 11403   
                 case TIMEZONE:
 11404   
                 case TRUE:
 11405   
                 case TZ:
 11406   
                 case UCASE:
 11407   
                 case URI:
 11408   
                 case VAR1:
 11409   
                 case VAR2:
 11410   
                 case YEAR:
 11411   
                     {
 11412  28 
                     alt81=2;
 11413   
                     }
 11414  28 
                     break;
 11415   
                 default:
 11416  0 
                     NoViableAltException nvae =
 11417   
                         new NoViableAltException("", 81, 1, input);
 11418   
 
 11419  0 
                     throw nvae;
 11420   
 
 11421   
                 }
 11422   
 
 11423   
                 }
 11424  30 
                 break;
 11425   
             default:
 11426  0 
                 NoViableAltException nvae =
 11427   
                     new NoViableAltException("", 81, 0, input);
 11428   
 
 11429  0 
                 throw nvae;
 11430   
 
 11431   
             }
 11432   
 
 11433  30 
             switch (alt81) {
 11434   
                 case 1 :
 11435   
                     // com\\googlecode\\sparkleg\\Sparql.g:353:8: nil
 11436   
                     {
 11437  2 
                     pushFollow(FOLLOW_nil_in_expressionList2891);
 11438  2 
                     nil252=nil();
 11439   
 
 11440  2 
                     state._fsp--;
 11441   
 
 11442  2 
                     stream_nil.add(nil252.getTree());
 11443   
 
 11444   
                     }
 11445  2 
                     break;
 11446   
                 case 2 :
 11447   
                     // com\\googlecode\\sparkleg\\Sparql.g:353:14: OPEN_BRACE expression ( COMMA expression )* CLOSE_BRACE
 11448   
                     {
 11449  28 
                     OPEN_BRACE253=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_expressionList2895);
 11450  28 
                     stream_OPEN_BRACE.add(OPEN_BRACE253);
 11451   
 
 11452   
 
 11453  28 
                     pushFollow(FOLLOW_expression_in_expressionList2897);
 11454  28 
                     expression254=expression();
 11455   
 
 11456  28 
                     state._fsp--;
 11457   
 
 11458  28 
                     stream_expression.add(expression254.getTree());
 11459   
 
 11460   
                     // com\\googlecode\\sparkleg\\Sparql.g:353:36: ( COMMA expression )*
 11461   
                     loop80:
 11462   
                     do {
 11463  62 
                         int alt80=2;
 11464  62 
                         switch ( input.LA(1) ) {
 11465   
                         case COMMA:
 11466   
                             {
 11467  34 
                             alt80=1;
 11468   
                             }
 11469   
                             break;
 11470   
 
 11471   
                         }
 11472   
 
 11473  62 
                         switch (alt80) {
 11474   
                             case 1 :
 11475   
                                 // com\\googlecode\\sparkleg\\Sparql.g:353:37: COMMA expression
 11476   
                                 {
 11477  34 
                                 COMMA255=(Token)match(input,COMMA,FOLLOW_COMMA_in_expressionList2900);
 11478  34 
                                 stream_COMMA.add(COMMA255);
 11479   
 
 11480   
 
 11481  34 
                                 pushFollow(FOLLOW_expression_in_expressionList2902);
 11482  34 
                                 expression256=expression();
 11483   
 
 11484  34 
                                 state._fsp--;
 11485   
 
 11486  34 
                                 stream_expression.add(expression256.getTree());
 11487   
 
 11488   
                                 }
 11489  34 
                                 break;
 11490   
 
 11491   
                             default :
 11492  28 
                                 break loop80;
 11493   
                         }
 11494  34 
                     } while (true);
 11495   
 
 11496   
 
 11497  28 
                     CLOSE_BRACE257=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_expressionList2906);
 11498  28 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE257);
 11499   
 
 11500   
 
 11501   
                     }
 11502   
                     break;
 11503   
 
 11504   
             }
 11505   
 
 11506   
 
 11507   
             // AST REWRITE
 11508   
             // elements: expression, nil
 11509   
             // token labels:
 11510   
             // rule labels: retval
 11511   
             // token list labels:
 11512   
             // rule list labels:
 11513   
             // wildcard labels:
 11514  30 
             retval.tree = root_0;
 11515  30 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11516   
 
 11517  30 
             root_0 = (Object)adaptor.nil();
 11518   
             // 353:69: -> ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11519   
             {
 11520   
                 // com\\googlecode\\sparkleg\\Sparql.g:353:72: ^( EXPRESSION_LIST ( nil )* ( expression )* )
 11521   
                 {
 11522  30 
                 Object root_1 = (Object)adaptor.nil();
 11523  30 
                 root_1 = (Object)adaptor.becomeRoot(
 11524   
                 (Object)adaptor.create(EXPRESSION_LIST, "EXPRESSION_LIST")
 11525   
                 , root_1);
 11526   
 
 11527   
                 // com\\googlecode\\sparkleg\\Sparql.g:353:90: ( nil )*
 11528  32 
                 while ( stream_nil.hasNext() ) {
 11529  2 
                     adaptor.addChild(root_1, stream_nil.nextTree());
 11530   
 
 11531   
                 }
 11532  30 
                 stream_nil.reset();
 11533   
 
 11534   
                 // com\\googlecode\\sparkleg\\Sparql.g:353:95: ( expression )*
 11535  92 
                 while ( stream_expression.hasNext() ) {
 11536  62 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 11537   
 
 11538   
                 }
 11539  30 
                 stream_expression.reset();
 11540   
 
 11541  30 
                 adaptor.addChild(root_0, root_1);
 11542   
                 }
 11543   
 
 11544   
             }
 11545   
 
 11546   
 
 11547  30 
             retval.tree = root_0;
 11548   
 
 11549   
             }
 11550   
 
 11551  30 
             retval.stop = input.LT(-1);
 11552   
 
 11553   
 
 11554  30 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11555  30 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11556   
 
 11557   
         }
 11558  0 
         catch (RecognitionException re) {
 11559  0 
             reportError(re);
 11560  0 
             recover(input,re);
 11561  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11562   
 
 11563   
         }
 11564   
 
 11565  0 
         finally {
 11566   
                 // do for sure before leaving
 11567  30 
         }
 11568  30 
         return retval;
 11569   
     }
 11570   
     // $ANTLR end "expressionList"
 11571   
 
 11572   
 
 11573  54 
     public static class constructTemplate_return extends ParserRuleReturnScope {
 11574   
         Object tree;
 11575  54 
         public Object getTree() { return tree; }
 11576   
     };
 11577   
 
 11578   
 
 11579   
     // $ANTLR start "constructTemplate"
 11580   
     // com\\googlecode\\sparkleg\\Sparql.g:356:1: constructTemplate : OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) ;
 11581   
     public final SparqlParser.constructTemplate_return constructTemplate() throws RecognitionException {
 11582  54 
         SparqlParser.constructTemplate_return retval = new SparqlParser.constructTemplate_return();
 11583  54 
         retval.start = input.LT(1);
 11584   
 
 11585   
 
 11586  54 
         Object root_0 = null;
 11587   
 
 11588  54 
         Token OPEN_CURLY_BRACE258=null;
 11589  54 
         Token CLOSE_CURLY_BRACE260=null;
 11590  54 
         SparqlParser.constructTriples_return constructTriples259 =null;
 11591   
 
 11592   
 
 11593  54 
         Object OPEN_CURLY_BRACE258_tree=null;
 11594  54 
         Object CLOSE_CURLY_BRACE260_tree=null;
 11595  54 
         RewriteRuleTokenStream stream_OPEN_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_CURLY_BRACE");
 11596  54 
         RewriteRuleTokenStream stream_CLOSE_CURLY_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_CURLY_BRACE");
 11597  54 
         RewriteRuleSubtreeStream stream_constructTriples=new RewriteRuleSubtreeStream(adaptor,"rule constructTriples");
 11598   
         try {
 11599   
             // com\\googlecode\\sparkleg\\Sparql.g:357:5: ( OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE -> ^( CONSTRUCT_TRIPLES ( constructTriples )? ) )
 11600   
             // com\\googlecode\\sparkleg\\Sparql.g:357:7: OPEN_CURLY_BRACE ( constructTriples )? CLOSE_CURLY_BRACE
 11601   
             {
 11602  54 
             OPEN_CURLY_BRACE258=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2937);
 11603  54 
             stream_OPEN_CURLY_BRACE.add(OPEN_CURLY_BRACE258);
 11604   
 
 11605   
 
 11606   
             // com\\googlecode\\sparkleg\\Sparql.g:357:24: ( constructTriples )?
 11607  54 
             int alt82=2;
 11608  54 
             switch ( input.LA(1) ) {
 11609   
                 case BLANK_NODE_LABEL:
 11610   
                 case DECIMAL:
 11611   
                 case DECIMAL_NEGATIVE:
 11612   
                 case DECIMAL_POSITIVE:
 11613   
                 case DOUBLE:
 11614   
                 case DOUBLE_NEGATIVE:
 11615   
                 case DOUBLE_POSITIVE:
 11616   
                 case FALSE:
 11617   
                 case INTEGER:
 11618   
                 case INTEGER_NEGATIVE:
 11619   
                 case INTEGER_POSITIVE:
 11620   
                 case IRI_REF:
 11621   
                 case OPEN_BRACE:
 11622   
                 case OPEN_SQUARE_BRACKET:
 11623   
                 case PNAME_LN:
 11624   
                 case PNAME_NS:
 11625   
                 case STRING_LITERAL1:
 11626   
                 case STRING_LITERAL2:
 11627   
                 case STRING_LITERAL_LONG1:
 11628   
                 case STRING_LITERAL_LONG2:
 11629   
                 case TRUE:
 11630   
                 case VAR1:
 11631   
                 case VAR2:
 11632   
                     {
 11633  52 
                     alt82=1;
 11634   
                     }
 11635   
                     break;
 11636   
             }
 11637   
 
 11638  54 
             switch (alt82) {
 11639   
                 case 1 :
 11640   
                     // com\\googlecode\\sparkleg\\Sparql.g:357:24: constructTriples
 11641   
                     {
 11642  52 
                     pushFollow(FOLLOW_constructTriples_in_constructTemplate2939);
 11643  52 
                     constructTriples259=constructTriples();
 11644   
 
 11645  52 
                     state._fsp--;
 11646   
 
 11647  52 
                     stream_constructTriples.add(constructTriples259.getTree());
 11648   
 
 11649   
                     }
 11650   
                     break;
 11651   
 
 11652   
             }
 11653   
 
 11654   
 
 11655  54 
             CLOSE_CURLY_BRACE260=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2942);
 11656  54 
             stream_CLOSE_CURLY_BRACE.add(CLOSE_CURLY_BRACE260);
 11657   
 
 11658   
 
 11659   
             // AST REWRITE
 11660   
             // elements: constructTriples
 11661   
             // token labels:
 11662   
             // rule labels: retval
 11663   
             // token list labels:
 11664   
             // rule list labels:
 11665   
             // wildcard labels:
 11666  54 
             retval.tree = root_0;
 11667  54 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11668   
 
 11669  54 
             root_0 = (Object)adaptor.nil();
 11670   
             // 357:60: -> ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11671   
             {
 11672   
                 // com\\googlecode\\sparkleg\\Sparql.g:357:63: ^( CONSTRUCT_TRIPLES ( constructTriples )? )
 11673   
                 {
 11674  54 
                 Object root_1 = (Object)adaptor.nil();
 11675  54 
                 root_1 = (Object)adaptor.becomeRoot(
 11676   
                 (Object)adaptor.create(CONSTRUCT_TRIPLES, "CONSTRUCT_TRIPLES")
 11677   
                 , root_1);
 11678   
 
 11679   
                 // com\\googlecode\\sparkleg\\Sparql.g:357:83: ( constructTriples )?
 11680  54 
                 if ( stream_constructTriples.hasNext() ) {
 11681  52 
                     adaptor.addChild(root_1, stream_constructTriples.nextTree());
 11682   
 
 11683   
                 }
 11684  54 
                 stream_constructTriples.reset();
 11685   
 
 11686  54 
                 adaptor.addChild(root_0, root_1);
 11687   
                 }
 11688   
 
 11689   
             }
 11690   
 
 11691   
 
 11692  54 
             retval.tree = root_0;
 11693   
 
 11694   
             }
 11695   
 
 11696  54 
             retval.stop = input.LT(-1);
 11697   
 
 11698   
 
 11699  54 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11700  54 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11701   
 
 11702   
         }
 11703  0 
         catch (RecognitionException re) {
 11704  0 
             reportError(re);
 11705  0 
             recover(input,re);
 11706  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11707   
 
 11708   
         }
 11709   
 
 11710  0 
         finally {
 11711   
                 // do for sure before leaving
 11712  54 
         }
 11713  54 
         return retval;
 11714   
     }
 11715   
     // $ANTLR end "constructTemplate"
 11716   
 
 11717   
 
 11718  52 
     public static class constructTriples_return extends ParserRuleReturnScope {
 11719   
         Object tree;
 11720  52 
         public Object getTree() { return tree; }
 11721   
     };
 11722   
 
 11723   
 
 11724   
     // $ANTLR start "constructTriples"
 11725   
     // com\\googlecode\\sparkleg\\Sparql.g:360:1: constructTriples : triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ ;
 11726   
     public final SparqlParser.constructTriples_return constructTriples() throws RecognitionException {
 11727  52 
         SparqlParser.constructTriples_return retval = new SparqlParser.constructTriples_return();
 11728  52 
         retval.start = input.LT(1);
 11729   
 
 11730   
 
 11731  52 
         Object root_0 = null;
 11732   
 
 11733  52 
         Token DOT262=null;
 11734  52 
         Token DOT264=null;
 11735  52 
         SparqlParser.triplesSameSubject_return triplesSameSubject261 =null;
 11736   
 
 11737  52 
         SparqlParser.triplesSameSubject_return triplesSameSubject263 =null;
 11738   
 
 11739   
 
 11740  52 
         Object DOT262_tree=null;
 11741  52 
         Object DOT264_tree=null;
 11742  52 
         RewriteRuleTokenStream stream_DOT=new RewriteRuleTokenStream(adaptor,"token DOT");
 11743  52 
         RewriteRuleSubtreeStream stream_triplesSameSubject=new RewriteRuleSubtreeStream(adaptor,"rule triplesSameSubject");
 11744   
         try {
 11745   
             // com\\googlecode\\sparkleg\\Sparql.g:361:5: ( triplesSameSubject ( DOT triplesSameSubject )* ( DOT )? -> ( triplesSameSubject )+ )
 11746   
             // com\\googlecode\\sparkleg\\Sparql.g:361:7: triplesSameSubject ( DOT triplesSameSubject )* ( DOT )?
 11747   
             {
 11748  52 
             pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2968);
 11749  52 
             triplesSameSubject261=triplesSameSubject();
 11750   
 
 11751  52 
             state._fsp--;
 11752   
 
 11753  52 
             stream_triplesSameSubject.add(triplesSameSubject261.getTree());
 11754   
 
 11755   
             // com\\googlecode\\sparkleg\\Sparql.g:361:26: ( DOT triplesSameSubject )*
 11756   
             loop83:
 11757   
             do {
 11758  68 
                 int alt83=2;
 11759  68 
                 switch ( input.LA(1) ) {
 11760   
                 case DOT:
 11761   
                     {
 11762  48 
                     switch ( input.LA(2) ) {
 11763   
                     case BLANK_NODE_LABEL:
 11764   
                     case DECIMAL:
 11765   
                     case DECIMAL_NEGATIVE:
 11766   
                     case DECIMAL_POSITIVE:
 11767   
                     case DOUBLE:
 11768   
                     case DOUBLE_NEGATIVE:
 11769   
                     case DOUBLE_POSITIVE:
 11770   
                     case FALSE:
 11771   
                     case INTEGER:
 11772   
                     case INTEGER_NEGATIVE:
 11773   
                     case INTEGER_POSITIVE:
 11774   
                     case IRI_REF:
 11775   
                     case OPEN_BRACE:
 11776   
                     case OPEN_SQUARE_BRACKET:
 11777   
                     case PNAME_LN:
 11778   
                     case PNAME_NS:
 11779   
                     case STRING_LITERAL1:
 11780   
                     case STRING_LITERAL2:
 11781   
                     case STRING_LITERAL_LONG1:
 11782   
                     case STRING_LITERAL_LONG2:
 11783   
                     case TRUE:
 11784   
                     case VAR1:
 11785   
                     case VAR2:
 11786   
                         {
 11787  16 
                         alt83=1;
 11788   
                         }
 11789   
                         break;
 11790   
 
 11791   
                     }
 11792   
 
 11793   
                     }
 11794   
                     break;
 11795   
 
 11796   
                 }
 11797   
 
 11798  68 
                 switch (alt83) {
 11799   
                     case 1 :
 11800   
                         // com\\googlecode\\sparkleg\\Sparql.g:361:27: DOT triplesSameSubject
 11801   
                         {
 11802  16 
                         DOT262=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2971);
 11803  16 
                         stream_DOT.add(DOT262);
 11804   
 
 11805   
 
 11806  16 
                         pushFollow(FOLLOW_triplesSameSubject_in_constructTriples2973);
 11807  16 
                         triplesSameSubject263=triplesSameSubject();
 11808   
 
 11809  16 
                         state._fsp--;
 11810   
 
 11811  16 
                         stream_triplesSameSubject.add(triplesSameSubject263.getTree());
 11812   
 
 11813   
                         }
 11814  16 
                         break;
 11815   
 
 11816   
                     default :
 11817  52 
                         break loop83;
 11818   
                 }
 11819  16 
             } while (true);
 11820   
 
 11821   
 
 11822   
             // com\\googlecode\\sparkleg\\Sparql.g:361:52: ( DOT )?
 11823  52 
             int alt84=2;
 11824  52 
             switch ( input.LA(1) ) {
 11825   
                 case DOT:
 11826   
                     {
 11827  32 
                     alt84=1;
 11828   
                     }
 11829   
                     break;
 11830   
             }
 11831   
 
 11832  52 
             switch (alt84) {
 11833   
                 case 1 :
 11834   
                     // com\\googlecode\\sparkleg\\Sparql.g:361:52: DOT
 11835   
                     {
 11836  32 
                     DOT264=(Token)match(input,DOT,FOLLOW_DOT_in_constructTriples2977);
 11837  32 
                     stream_DOT.add(DOT264);
 11838   
 
 11839   
 
 11840   
                     }
 11841   
                     break;
 11842   
 
 11843   
             }
 11844   
 
 11845   
 
 11846   
             // AST REWRITE
 11847   
             // elements: triplesSameSubject
 11848   
             // token labels:
 11849   
             // rule labels: retval
 11850   
             // token list labels:
 11851   
             // rule list labels:
 11852   
             // wildcard labels:
 11853  52 
             retval.tree = root_0;
 11854  52 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 11855   
 
 11856  52 
             root_0 = (Object)adaptor.nil();
 11857   
             // 361:57: -> ( triplesSameSubject )+
 11858   
             {
 11859  52 
                 if ( !(stream_triplesSameSubject.hasNext()) ) {
 11860  0 
                     throw new RewriteEarlyExitException();
 11861   
                 }
 11862  120 
                 while ( stream_triplesSameSubject.hasNext() ) {
 11863  68 
                     adaptor.addChild(root_0, stream_triplesSameSubject.nextTree());
 11864   
 
 11865   
                 }
 11866  52 
                 stream_triplesSameSubject.reset();
 11867   
 
 11868   
             }
 11869   
 
 11870   
 
 11871  52 
             retval.tree = root_0;
 11872   
 
 11873   
             }
 11874   
 
 11875  52 
             retval.stop = input.LT(-1);
 11876   
 
 11877   
 
 11878  52 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 11879  52 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 11880   
 
 11881   
         }
 11882  0 
         catch (RecognitionException re) {
 11883  0 
             reportError(re);
 11884  0 
             recover(input,re);
 11885  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 11886   
 
 11887   
         }
 11888   
 
 11889  0 
         finally {
 11890   
                 // do for sure before leaving
 11891  52 
         }
 11892  52 
         return retval;
 11893   
     }
 11894   
     // $ANTLR end "constructTriples"
 11895   
 
 11896   
 
 11897  194 
     public static class triplesSameSubject_return extends ParserRuleReturnScope {
 11898   
         Object tree;
 11899  194 
         public Object getTree() { return tree; }
 11900   
     };
 11901   
 
 11902   
 
 11903   
     // $ANTLR start "triplesSameSubject"
 11904   
     // com\\googlecode\\sparkleg\\Sparql.g:364:1: triplesSameSubject : ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 11905   
     public final SparqlParser.triplesSameSubject_return triplesSameSubject() throws RecognitionException {
 11906  194 
         SparqlParser.triplesSameSubject_return retval = new SparqlParser.triplesSameSubject_return();
 11907  194 
         retval.start = input.LT(1);
 11908   
 
 11909   
 
 11910  194 
         Object root_0 = null;
 11911   
 
 11912  194 
         SparqlParser.varOrTerm_return varOrTerm265 =null;
 11913   
 
 11914  194 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty266 =null;
 11915   
 
 11916  194 
         SparqlParser.triplesNode_return triplesNode267 =null;
 11917   
 
 11918  194 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty268 =null;
 11919   
 
 11920   
 
 11921  194 
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 11922  194 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 11923  194 
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 11924   
         try {
 11925   
             // com\\googlecode\\sparkleg\\Sparql.g:365:5: ( varOrTerm ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 11926  194 
             int alt87=2;
 11927  194 
             switch ( input.LA(1) ) {
 11928   
             case BLANK_NODE_LABEL:
 11929   
             case DECIMAL:
 11930   
             case DECIMAL_NEGATIVE:
 11931   
             case DECIMAL_POSITIVE:
 11932   
             case DOUBLE:
 11933   
             case DOUBLE_NEGATIVE:
 11934   
             case DOUBLE_POSITIVE:
 11935   
             case FALSE:
 11936   
             case INTEGER:
 11937   
             case INTEGER_NEGATIVE:
 11938   
             case INTEGER_POSITIVE:
 11939   
             case IRI_REF:
 11940   
             case PNAME_LN:
 11941   
             case PNAME_NS:
 11942   
             case STRING_LITERAL1:
 11943   
             case STRING_LITERAL2:
 11944   
             case STRING_LITERAL_LONG1:
 11945   
             case STRING_LITERAL_LONG2:
 11946   
             case TRUE:
 11947   
             case VAR1:
 11948   
             case VAR2:
 11949   
                 {
 11950  182 
                 alt87=1;
 11951   
                 }
 11952  182 
                 break;
 11953   
             case OPEN_SQUARE_BRACKET:
 11954   
                 {
 11955  12 
                 switch ( input.LA(2) ) {
 11956   
                 case CLOSE_SQUARE_BRACKET:
 11957   
                     {
 11958  10 
                     alt87=1;
 11959   
                     }
 11960  10 
                     break;
 11961   
                 case A:
 11962   
                 case INVERSE:
 11963   
                 case IRI_REF:
 11964   
                 case NEGATION:
 11965   
                 case OPEN_BRACE:
 11966   
                 case PNAME_LN:
 11967   
                 case PNAME_NS:
 11968   
                 case VAR1:
 11969   
                 case VAR2:
 11970   
                     {
 11971  2 
                     alt87=2;
 11972   
                     }
 11973  2 
                     break;
 11974   
                 default:
 11975  0 
                     NoViableAltException nvae =
 11976   
                         new NoViableAltException("", 87, 2, input);
 11977   
 
 11978  0 
                     throw nvae;
 11979   
 
 11980   
                 }
 11981   
 
 11982   
                 }
 11983  12 
                 break;
 11984   
             case OPEN_BRACE:
 11985   
                 {
 11986  0 
                 switch ( input.LA(2) ) {
 11987   
                 case CLOSE_BRACE:
 11988   
                     {
 11989  0 
                     alt87=1;
 11990   
                     }
 11991  0 
                     break;
 11992   
                 case BLANK_NODE_LABEL:
 11993   
                 case DECIMAL:
 11994   
                 case DECIMAL_NEGATIVE:
 11995   
                 case DECIMAL_POSITIVE:
 11996   
                 case DOUBLE:
 11997   
                 case DOUBLE_NEGATIVE:
 11998   
                 case DOUBLE_POSITIVE:
 11999   
                 case FALSE:
 12000   
                 case INTEGER:
 12001   
                 case INTEGER_NEGATIVE:
 12002   
                 case INTEGER_POSITIVE:
 12003   
                 case IRI_REF:
 12004   
                 case OPEN_BRACE:
 12005   
                 case OPEN_SQUARE_BRACKET:
 12006   
                 case PNAME_LN:
 12007   
                 case PNAME_NS:
 12008   
                 case STRING_LITERAL1:
 12009   
                 case STRING_LITERAL2:
 12010   
                 case STRING_LITERAL_LONG1:
 12011   
                 case STRING_LITERAL_LONG2:
 12012   
                 case TRUE:
 12013   
                 case VAR1:
 12014   
                 case VAR2:
 12015   
                     {
 12016  0 
                     alt87=2;
 12017   
                     }
 12018  0 
                     break;
 12019   
                 default:
 12020  0 
                     NoViableAltException nvae =
 12021   
                         new NoViableAltException("", 87, 3, input);
 12022   
 
 12023  0 
                     throw nvae;
 12024   
 
 12025   
                 }
 12026   
 
 12027   
                 }
 12028  0 
                 break;
 12029   
             default:
 12030  0 
                 NoViableAltException nvae =
 12031   
                     new NoViableAltException("", 87, 0, input);
 12032   
 
 12033  0 
                 throw nvae;
 12034   
 
 12035   
             }
 12036   
 
 12037  194 
             switch (alt87) {
 12038   
                 case 1 :
 12039   
                     // com\\googlecode\\sparkleg\\Sparql.g:365:7: varOrTerm ( propertyListNotEmpty )?
 12040   
                     {
 12041  192 
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubject3000);
 12042  192 
                     varOrTerm265=varOrTerm();
 12043   
 
 12044  192 
                     state._fsp--;
 12045   
 
 12046  192 
                     stream_varOrTerm.add(varOrTerm265.getTree());
 12047   
 
 12048   
                     // com\\googlecode\\sparkleg\\Sparql.g:365:17: ( propertyListNotEmpty )?
 12049  192 
                     int alt85=2;
 12050  192 
                     switch ( input.LA(1) ) {
 12051   
                         case A:
 12052   
                         case INVERSE:
 12053   
                         case IRI_REF:
 12054   
                         case NEGATION:
 12055   
                         case OPEN_BRACE:
 12056   
                         case PNAME_LN:
 12057   
                         case PNAME_NS:
 12058   
                         case VAR1:
 12059   
                         case VAR2:
 12060   
                             {
 12061  192 
                             alt85=1;
 12062   
                             }
 12063   
                             break;
 12064   
                     }
 12065   
 
 12066  192 
                     switch (alt85) {
 12067   
                         case 1 :
 12068   
                             // com\\googlecode\\sparkleg\\Sparql.g:365:17: propertyListNotEmpty
 12069   
                             {
 12070  192 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3002);
 12071  192 
                             propertyListNotEmpty266=propertyListNotEmpty();
 12072   
 
 12073  192 
                             state._fsp--;
 12074   
 
 12075  192 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty266.getTree());
 12076   
 
 12077   
                             }
 12078   
                             break;
 12079   
 
 12080   
                     }
 12081   
 
 12082   
 
 12083   
                     // AST REWRITE
 12084   
                     // elements: propertyListNotEmpty, varOrTerm
 12085   
                     // token labels:
 12086   
                     // rule labels: retval
 12087   
                     // token list labels:
 12088   
                     // rule list labels:
 12089   
                     // wildcard labels:
 12090  192 
                     retval.tree = root_0;
 12091  192 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12092   
 
 12093  192 
                     root_0 = (Object)adaptor.nil();
 12094   
                     // 365:39: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12095   
                     {
 12096   
                         // com\\googlecode\\sparkleg\\Sparql.g:365:42: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) ( propertyListNotEmpty )? )
 12097   
                         {
 12098  192 
                         Object root_1 = (Object)adaptor.nil();
 12099  192 
                         root_1 = (Object)adaptor.becomeRoot(
 12100   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12101   
                         , root_1);
 12102   
 
 12103   
                         // com\\googlecode\\sparkleg\\Sparql.g:365:65: ^( SUBJECT varOrTerm )
 12104   
                         {
 12105  192 
                         Object root_2 = (Object)adaptor.nil();
 12106  192 
                         root_2 = (Object)adaptor.becomeRoot(
 12107   
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12108   
                         , root_2);
 12109   
 
 12110  192 
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12111   
 
 12112  192 
                         adaptor.addChild(root_1, root_2);
 12113   
                         }
 12114   
 
 12115   
                         // com\\googlecode\\sparkleg\\Sparql.g:365:86: ( propertyListNotEmpty )?
 12116  192 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12117  192 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12118   
 
 12119   
                         }
 12120  192 
                         stream_propertyListNotEmpty.reset();
 12121   
 
 12122  192 
                         adaptor.addChild(root_0, root_1);
 12123   
                         }
 12124   
 
 12125   
                     }
 12126   
 
 12127   
 
 12128  192 
                     retval.tree = root_0;
 12129   
 
 12130   
                     }
 12131  192 
                     break;
 12132   
                 case 2 :
 12133   
                     // com\\googlecode\\sparkleg\\Sparql.g:366:7: triplesNode ( propertyListNotEmpty )?
 12134   
                     {
 12135  2 
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubject3026);
 12136  2 
                     triplesNode267=triplesNode();
 12137   
 
 12138  2 
                     state._fsp--;
 12139   
 
 12140  2 
                     stream_triplesNode.add(triplesNode267.getTree());
 12141   
 
 12142   
                     // com\\googlecode\\sparkleg\\Sparql.g:366:19: ( propertyListNotEmpty )?
 12143  2 
                     int alt86=2;
 12144  2 
                     switch ( input.LA(1) ) {
 12145   
                         case A:
 12146   
                         case INVERSE:
 12147   
                         case IRI_REF:
 12148   
                         case NEGATION:
 12149   
                         case OPEN_BRACE:
 12150   
                         case PNAME_LN:
 12151   
                         case PNAME_NS:
 12152   
                         case VAR1:
 12153   
                         case VAR2:
 12154   
                             {
 12155  0 
                             alt86=1;
 12156   
                             }
 12157   
                             break;
 12158   
                     }
 12159   
 
 12160  2 
                     switch (alt86) {
 12161   
                         case 1 :
 12162   
                             // com\\googlecode\\sparkleg\\Sparql.g:366:19: propertyListNotEmpty
 12163   
                             {
 12164  0 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubject3028);
 12165  0 
                             propertyListNotEmpty268=propertyListNotEmpty();
 12166   
 
 12167  0 
                             state._fsp--;
 12168   
 
 12169  0 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty268.getTree());
 12170   
 
 12171   
                             }
 12172   
                             break;
 12173   
 
 12174   
                     }
 12175   
 
 12176   
 
 12177   
                     // AST REWRITE
 12178   
                     // elements: propertyListNotEmpty, triplesNode
 12179   
                     // token labels:
 12180   
                     // rule labels: retval
 12181   
                     // token list labels:
 12182   
                     // rule list labels:
 12183   
                     // wildcard labels:
 12184  2 
                     retval.tree = root_0;
 12185  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12186   
 
 12187  2 
                     root_0 = (Object)adaptor.nil();
 12188   
                     // 366:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12189   
                     {
 12190   
                         // com\\googlecode\\sparkleg\\Sparql.g:366:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12191   
                         {
 12192  2 
                         Object root_1 = (Object)adaptor.nil();
 12193  2 
                         root_1 = (Object)adaptor.becomeRoot(
 12194   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12195   
                         , root_1);
 12196   
 
 12197  2 
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12198   
 
 12199   
                         // com\\googlecode\\sparkleg\\Sparql.g:366:79: ( propertyListNotEmpty )?
 12200  2 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12201  0 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12202   
 
 12203   
                         }
 12204  2 
                         stream_propertyListNotEmpty.reset();
 12205   
 
 12206  2 
                         adaptor.addChild(root_0, root_1);
 12207   
                         }
 12208   
 
 12209   
                     }
 12210   
 
 12211   
 
 12212  2 
                     retval.tree = root_0;
 12213   
 
 12214   
                     }
 12215   
                     break;
 12216   
 
 12217   
             }
 12218  194 
             retval.stop = input.LT(-1);
 12219   
 
 12220   
 
 12221  194 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12222  194 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12223   
 
 12224   
         }
 12225  0 
         catch (RecognitionException re) {
 12226  0 
             reportError(re);
 12227  0 
             recover(input,re);
 12228  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12229   
 
 12230   
         }
 12231   
 
 12232  0 
         finally {
 12233   
                 // do for sure before leaving
 12234  194 
         }
 12235  194 
         return retval;
 12236   
     }
 12237   
     // $ANTLR end "triplesSameSubject"
 12238   
 
 12239   
 
 12240  240 
     public static class propertyListNotEmpty_return extends ParserRuleReturnScope {
 12241   
         Object tree;
 12242  240 
         public Object getTree() { return tree; }
 12243   
     };
 12244   
 
 12245   
 
 12246   
     // $ANTLR start "propertyListNotEmpty"
 12247   
     // com\\googlecode\\sparkleg\\Sparql.g:369:1: propertyListNotEmpty : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12248   
     public final SparqlParser.propertyListNotEmpty_return propertyListNotEmpty() throws RecognitionException {
 12249  240 
         SparqlParser.propertyListNotEmpty_return retval = new SparqlParser.propertyListNotEmpty_return();
 12250  240 
         retval.start = input.LT(1);
 12251   
 
 12252   
 
 12253  240 
         Object root_0 = null;
 12254   
 
 12255  240 
         Token SEMICOLON270=null;
 12256  240 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails269 =null;
 12257   
 
 12258  240 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails271 =null;
 12259   
 
 12260   
 
 12261  240 
         Object SEMICOLON270_tree=null;
 12262  240 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12263  240 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12264   
         try {
 12265   
             // com\\googlecode\\sparkleg\\Sparql.g:370:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12266   
             // com\\googlecode\\sparkleg\\Sparql.g:370:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12267   
             {
 12268  240 
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3058);
 12269  240 
             propertyListNotEmptyDetails269=propertyListNotEmptyDetails();
 12270   
 
 12271  240 
             state._fsp--;
 12272   
 
 12273  240 
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails269.getTree());
 12274   
 
 12275   
             // com\\googlecode\\sparkleg\\Sparql.g:370:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12276   
             loop89:
 12277   
             do {
 12278  273 
                 int alt89=2;
 12279  273 
                 switch ( input.LA(1) ) {
 12280   
                 case SEMICOLON:
 12281   
                     {
 12282  33 
                     alt89=1;
 12283   
                     }
 12284   
                     break;
 12285   
 
 12286   
                 }
 12287   
 
 12288  273 
                 switch (alt89) {
 12289   
                     case 1 :
 12290   
                         // com\\googlecode\\sparkleg\\Sparql.g:370:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12291   
                         {
 12292  33 
                         SEMICOLON270=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmpty3061);
 12293  33 
                         stream_SEMICOLON.add(SEMICOLON270);
 12294   
 
 12295   
 
 12296   
                         // com\\googlecode\\sparkleg\\Sparql.g:370:46: ( propertyListNotEmptyDetails )?
 12297  33 
                         int alt88=2;
 12298  33 
                         switch ( input.LA(1) ) {
 12299   
                             case A:
 12300   
                             case INVERSE:
 12301   
                             case IRI_REF:
 12302   
                             case NEGATION:
 12303   
                             case OPEN_BRACE:
 12304   
                             case PNAME_LN:
 12305   
                             case PNAME_NS:
 12306   
                             case VAR1:
 12307   
                             case VAR2:
 12308   
                                 {
 12309  32 
                                 alt88=1;
 12310   
                                 }
 12311   
                                 break;
 12312   
                         }
 12313   
 
 12314  33 
                         switch (alt88) {
 12315   
                             case 1 :
 12316   
                                 // com\\googlecode\\sparkleg\\Sparql.g:370:46: propertyListNotEmptyDetails
 12317   
                                 {
 12318  32 
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3063);
 12319  32 
                                 propertyListNotEmptyDetails271=propertyListNotEmptyDetails();
 12320   
 
 12321  32 
                                 state._fsp--;
 12322   
 
 12323  32 
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails271.getTree());
 12324   
 
 12325   
                                 }
 12326   
                                 break;
 12327   
 
 12328   
                         }
 12329   
 
 12330   
 
 12331   
                         }
 12332  33 
                         break;
 12333   
 
 12334   
                     default :
 12335  240 
                         break loop89;
 12336   
                 }
 12337  33 
             } while (true);
 12338   
 
 12339   
 
 12340   
             // AST REWRITE
 12341   
             // elements: propertyListNotEmptyDetails
 12342   
             // token labels:
 12343   
             // rule labels: retval
 12344   
             // token list labels:
 12345   
             // rule list labels:
 12346   
             // wildcard labels:
 12347  240 
             retval.tree = root_0;
 12348  240 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12349   
 
 12350  240 
             root_0 = (Object)adaptor.nil();
 12351   
             // 370:77: -> ( propertyListNotEmptyDetails )+
 12352   
             {
 12353  240 
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 12354  0 
                     throw new RewriteEarlyExitException();
 12355   
                 }
 12356  512 
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 12357  272 
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 12358   
 
 12359   
                 }
 12360  240 
                 stream_propertyListNotEmptyDetails.reset();
 12361   
 
 12362   
             }
 12363   
 
 12364   
 
 12365  240 
             retval.tree = root_0;
 12366   
 
 12367   
             }
 12368   
 
 12369  240 
             retval.stop = input.LT(-1);
 12370   
 
 12371   
 
 12372  240 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12373  240 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12374   
 
 12375   
         }
 12376  0 
         catch (RecognitionException re) {
 12377  0 
             reportError(re);
 12378  0 
             recover(input,re);
 12379  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12380   
 
 12381   
         }
 12382   
 
 12383  0 
         finally {
 12384   
                 // do for sure before leaving
 12385  240 
         }
 12386  240 
         return retval;
 12387   
     }
 12388   
     // $ANTLR end "propertyListNotEmpty"
 12389   
 
 12390   
 
 12391  3354 
     public static class objectList_return extends ParserRuleReturnScope {
 12392   
         Object tree;
 12393  3354 
         public Object getTree() { return tree; }
 12394   
     };
 12395   
 
 12396   
 
 12397   
     // $ANTLR start "objectList"
 12398   
     // com\\googlecode\\sparkleg\\Sparql.g:373:1: objectList : graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ ;
 12399   
     public final SparqlParser.objectList_return objectList() throws RecognitionException {
 12400  3354 
         SparqlParser.objectList_return retval = new SparqlParser.objectList_return();
 12401  3354 
         retval.start = input.LT(1);
 12402   
 
 12403   
 
 12404  3354 
         Object root_0 = null;
 12405   
 
 12406  3354 
         Token COMMA273=null;
 12407  3354 
         SparqlParser.graphNode_return graphNode272 =null;
 12408   
 
 12409  3354 
         SparqlParser.graphNode_return graphNode274 =null;
 12410   
 
 12411   
 
 12412  3354 
         Object COMMA273_tree=null;
 12413  3354 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 12414  3354 
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 12415   
         try {
 12416   
             // com\\googlecode\\sparkleg\\Sparql.g:374:5: ( graphNode ( COMMA graphNode )* -> ( ^( OBJECT graphNode ) )+ )
 12417   
             // com\\googlecode\\sparkleg\\Sparql.g:374:7: graphNode ( COMMA graphNode )*
 12418   
             {
 12419  3354 
             pushFollow(FOLLOW_graphNode_in_objectList3089);
 12420  3354 
             graphNode272=graphNode();
 12421   
 
 12422  3354 
             state._fsp--;
 12423   
 
 12424  3354 
             stream_graphNode.add(graphNode272.getTree());
 12425   
 
 12426   
             // com\\googlecode\\sparkleg\\Sparql.g:374:17: ( COMMA graphNode )*
 12427   
             loop90:
 12428   
             do {
 12429  3358 
                 int alt90=2;
 12430  3358 
                 switch ( input.LA(1) ) {
 12431   
                 case COMMA:
 12432   
                     {
 12433  4 
                     alt90=1;
 12434   
                     }
 12435   
                     break;
 12436   
 
 12437   
                 }
 12438   
 
 12439  3358 
                 switch (alt90) {
 12440   
                     case 1 :
 12441   
                         // com\\googlecode\\sparkleg\\Sparql.g:374:18: COMMA graphNode
 12442   
                         {
 12443  4 
                         COMMA273=(Token)match(input,COMMA,FOLLOW_COMMA_in_objectList3092);
 12444  4 
                         stream_COMMA.add(COMMA273);
 12445   
 
 12446   
 
 12447  4 
                         pushFollow(FOLLOW_graphNode_in_objectList3094);
 12448  4 
                         graphNode274=graphNode();
 12449   
 
 12450  4 
                         state._fsp--;
 12451   
 
 12452  4 
                         stream_graphNode.add(graphNode274.getTree());
 12453   
 
 12454   
                         }
 12455  4 
                         break;
 12456   
 
 12457   
                     default :
 12458  3354 
                         break loop90;
 12459   
                 }
 12460  4 
             } while (true);
 12461   
 
 12462   
 
 12463   
             // AST REWRITE
 12464   
             // elements: graphNode
 12465   
             // token labels:
 12466   
             // rule labels: retval
 12467   
             // token list labels:
 12468   
             // rule list labels:
 12469   
             // wildcard labels:
 12470  3354 
             retval.tree = root_0;
 12471  3354 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12472   
 
 12473  3354 
             root_0 = (Object)adaptor.nil();
 12474   
             // 374:36: -> ( ^( OBJECT graphNode ) )+
 12475   
             {
 12476  3354 
                 if ( !(stream_graphNode.hasNext()) ) {
 12477  0 
                     throw new RewriteEarlyExitException();
 12478   
                 }
 12479  6712 
                 while ( stream_graphNode.hasNext() ) {
 12480   
                     // com\\googlecode\\sparkleg\\Sparql.g:374:39: ^( OBJECT graphNode )
 12481   
                     {
 12482  3358 
                     Object root_1 = (Object)adaptor.nil();
 12483  3358 
                     root_1 = (Object)adaptor.becomeRoot(
 12484   
                     (Object)adaptor.create(OBJECT, "OBJECT")
 12485   
                     , root_1);
 12486   
 
 12487  3358 
                     adaptor.addChild(root_1, stream_graphNode.nextTree());
 12488   
 
 12489  3358 
                     adaptor.addChild(root_0, root_1);
 12490  3358 
                     }
 12491   
 
 12492   
                 }
 12493  3354 
                 stream_graphNode.reset();
 12494   
 
 12495   
             }
 12496   
 
 12497   
 
 12498  3354 
             retval.tree = root_0;
 12499   
 
 12500   
             }
 12501   
 
 12502  3354 
             retval.stop = input.LT(-1);
 12503   
 
 12504   
 
 12505  3354 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12506  3354 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12507   
 
 12508   
         }
 12509  0 
         catch (RecognitionException re) {
 12510  0 
             reportError(re);
 12511  0 
             recover(input,re);
 12512  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12513   
 
 12514   
         }
 12515   
 
 12516  0 
         finally {
 12517   
                 // do for sure before leaving
 12518  3354 
         }
 12519  3354 
         return retval;
 12520   
     }
 12521   
     // $ANTLR end "objectList"
 12522   
 
 12523   
 
 12524  0 
     public static class verb_return extends ParserRuleReturnScope {
 12525   
         Object tree;
 12526  0 
         public Object getTree() { return tree; }
 12527   
     };
 12528   
 
 12529   
 
 12530   
     // $ANTLR start "verb"
 12531   
     // com\\googlecode\\sparkleg\\Sparql.g:377:1: verb : ( varOrIRIref | A );
 12532   
     public final SparqlParser.verb_return verb() throws RecognitionException {
 12533  0 
         SparqlParser.verb_return retval = new SparqlParser.verb_return();
 12534  0 
         retval.start = input.LT(1);
 12535   
 
 12536   
 
 12537  0 
         Object root_0 = null;
 12538   
 
 12539  0 
         Token A276=null;
 12540  0 
         SparqlParser.varOrIRIref_return varOrIRIref275 =null;
 12541   
 
 12542   
 
 12543  0 
         Object A276_tree=null;
 12544   
 
 12545   
         try {
 12546   
             // com\\googlecode\\sparkleg\\Sparql.g:378:5: ( varOrIRIref | A )
 12547  0 
             int alt91=2;
 12548  0 
             switch ( input.LA(1) ) {
 12549   
             case IRI_REF:
 12550   
             case PNAME_LN:
 12551   
             case PNAME_NS:
 12552   
             case VAR1:
 12553   
             case VAR2:
 12554   
                 {
 12555  0 
                 alt91=1;
 12556   
                 }
 12557  0 
                 break;
 12558   
             case A:
 12559   
                 {
 12560  0 
                 alt91=2;
 12561   
                 }
 12562  0 
                 break;
 12563   
             default:
 12564  0 
                 NoViableAltException nvae =
 12565   
                     new NoViableAltException("", 91, 0, input);
 12566   
 
 12567  0 
                 throw nvae;
 12568   
 
 12569   
             }
 12570   
 
 12571  0 
             switch (alt91) {
 12572   
                 case 1 :
 12573   
                     // com\\googlecode\\sparkleg\\Sparql.g:378:7: varOrIRIref
 12574   
                     {
 12575  0 
                     root_0 = (Object)adaptor.nil();
 12576   
 
 12577   
 
 12578  0 
                     pushFollow(FOLLOW_varOrIRIref_in_verb3122);
 12579  0 
                     varOrIRIref275=varOrIRIref();
 12580   
 
 12581  0 
                     state._fsp--;
 12582   
 
 12583  0 
                     adaptor.addChild(root_0, varOrIRIref275.getTree());
 12584   
 
 12585   
                     }
 12586  0 
                     break;
 12587   
                 case 2 :
 12588   
                     // com\\googlecode\\sparkleg\\Sparql.g:379:7: A
 12589   
                     {
 12590  0 
                     root_0 = (Object)adaptor.nil();
 12591   
 
 12592   
 
 12593  0 
                     A276=(Token)match(input,A,FOLLOW_A_in_verb3130);
 12594  0 
                     A276_tree =
 12595   
                     (Object)adaptor.create(A276)
 12596   
                     ;
 12597  0 
                     adaptor.addChild(root_0, A276_tree);
 12598   
 
 12599   
 
 12600   
                     }
 12601   
                     break;
 12602   
 
 12603   
             }
 12604  0 
             retval.stop = input.LT(-1);
 12605   
 
 12606   
 
 12607  0 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12608  0 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12609   
 
 12610   
         }
 12611  0 
         catch (RecognitionException re) {
 12612  0 
             reportError(re);
 12613  0 
             recover(input,re);
 12614  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12615   
 
 12616   
         }
 12617   
 
 12618  0 
         finally {
 12619   
                 // do for sure before leaving
 12620  0 
         }
 12621  0 
         return retval;
 12622   
     }
 12623   
     // $ANTLR end "verb"
 12624   
 
 12625   
 
 12626  2914 
     public static class triplesSameSubjectPath_return extends ParserRuleReturnScope {
 12627   
         Object tree;
 12628  2914 
         public Object getTree() { return tree; }
 12629   
     };
 12630   
 
 12631   
 
 12632   
     // $ANTLR start "triplesSameSubjectPath"
 12633   
     // com\\googlecode\\sparkleg\\Sparql.g:382:1: triplesSameSubjectPath : ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) );
 12634   
     public final SparqlParser.triplesSameSubjectPath_return triplesSameSubjectPath() throws RecognitionException {
 12635  2914 
         SparqlParser.triplesSameSubjectPath_return retval = new SparqlParser.triplesSameSubjectPath_return();
 12636  2914 
         retval.start = input.LT(1);
 12637   
 
 12638   
 
 12639  2914 
         Object root_0 = null;
 12640   
 
 12641  2914 
         SparqlParser.varOrTerm_return varOrTerm277 =null;
 12642   
 
 12643  2914 
         SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath278 =null;
 12644   
 
 12645  2914 
         SparqlParser.triplesNode_return triplesNode279 =null;
 12646   
 
 12647  2914 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty280 =null;
 12648   
 
 12649   
 
 12650  2914 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 12651  2914 
         RewriteRuleSubtreeStream stream_varOrTerm=new RewriteRuleSubtreeStream(adaptor,"rule varOrTerm");
 12652  2914 
         RewriteRuleSubtreeStream stream_triplesNode=new RewriteRuleSubtreeStream(adaptor,"rule triplesNode");
 12653  2914 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyPath=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyPath");
 12654   
         try {
 12655   
             // com\\googlecode\\sparkleg\\Sparql.g:383:5: ( varOrTerm propertyListNotEmptyPath -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath ) | triplesNode ( propertyListNotEmpty )? -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? ) )
 12656  2914 
             int alt93=2;
 12657  2914 
             switch ( input.LA(1) ) {
 12658   
             case BLANK_NODE_LABEL:
 12659   
             case DECIMAL:
 12660   
             case DECIMAL_NEGATIVE:
 12661   
             case DECIMAL_POSITIVE:
 12662   
             case DOUBLE:
 12663   
             case DOUBLE_NEGATIVE:
 12664   
             case DOUBLE_POSITIVE:
 12665   
             case FALSE:
 12666   
             case INTEGER:
 12667   
             case INTEGER_NEGATIVE:
 12668   
             case INTEGER_POSITIVE:
 12669   
             case IRI_REF:
 12670   
             case PNAME_LN:
 12671   
             case PNAME_NS:
 12672   
             case STRING_LITERAL1:
 12673   
             case STRING_LITERAL2:
 12674   
             case STRING_LITERAL_LONG1:
 12675   
             case STRING_LITERAL_LONG2:
 12676   
             case TRUE:
 12677   
             case VAR1:
 12678   
             case VAR2:
 12679   
                 {
 12680  2826 
                 alt93=1;
 12681   
                 }
 12682  2826 
                 break;
 12683   
             case OPEN_SQUARE_BRACKET:
 12684   
                 {
 12685  66 
                 switch ( input.LA(2) ) {
 12686   
                 case CLOSE_SQUARE_BRACKET:
 12687   
                     {
 12688  52 
                     alt93=1;
 12689   
                     }
 12690  52 
                     break;
 12691   
                 case A:
 12692   
                 case INVERSE:
 12693   
                 case IRI_REF:
 12694   
                 case NEGATION:
 12695   
                 case OPEN_BRACE:
 12696   
                 case PNAME_LN:
 12697   
                 case PNAME_NS:
 12698   
                 case VAR1:
 12699   
                 case VAR2:
 12700   
                     {
 12701  14 
                     alt93=2;
 12702   
                     }
 12703  14 
                     break;
 12704   
                 default:
 12705  0 
                     NoViableAltException nvae =
 12706   
                         new NoViableAltException("", 93, 2, input);
 12707   
 
 12708  0 
                     throw nvae;
 12709   
 
 12710   
                 }
 12711   
 
 12712   
                 }
 12713  66 
                 break;
 12714   
             case OPEN_BRACE:
 12715   
                 {
 12716  22 
                 switch ( input.LA(2) ) {
 12717   
                 case CLOSE_BRACE:
 12718   
                     {
 12719  6 
                     alt93=1;
 12720   
                     }
 12721  6 
                     break;
 12722   
                 case BLANK_NODE_LABEL:
 12723   
                 case DECIMAL:
 12724   
                 case DECIMAL_NEGATIVE:
 12725   
                 case DECIMAL_POSITIVE:
 12726   
                 case DOUBLE:
 12727   
                 case DOUBLE_NEGATIVE:
 12728   
                 case DOUBLE_POSITIVE:
 12729   
                 case FALSE:
 12730   
                 case INTEGER:
 12731   
                 case INTEGER_NEGATIVE:
 12732   
                 case INTEGER_POSITIVE:
 12733   
                 case IRI_REF:
 12734   
                 case OPEN_BRACE:
 12735   
                 case OPEN_SQUARE_BRACKET:
 12736   
                 case PNAME_LN:
 12737   
                 case PNAME_NS:
 12738   
                 case STRING_LITERAL1:
 12739   
                 case STRING_LITERAL2:
 12740   
                 case STRING_LITERAL_LONG1:
 12741   
                 case STRING_LITERAL_LONG2:
 12742   
                 case TRUE:
 12743   
                 case VAR1:
 12744   
                 case VAR2:
 12745   
                     {
 12746  16 
                     alt93=2;
 12747   
                     }
 12748  16 
                     break;
 12749   
                 default:
 12750  0 
                     NoViableAltException nvae =
 12751   
                         new NoViableAltException("", 93, 3, input);
 12752   
 
 12753  0 
                     throw nvae;
 12754   
 
 12755   
                 }
 12756   
 
 12757   
                 }
 12758  22 
                 break;
 12759   
             default:
 12760  0 
                 NoViableAltException nvae =
 12761   
                     new NoViableAltException("", 93, 0, input);
 12762   
 
 12763  0 
                 throw nvae;
 12764   
 
 12765   
             }
 12766   
 
 12767  2914 
             switch (alt93) {
 12768   
                 case 1 :
 12769   
                     // com\\googlecode\\sparkleg\\Sparql.g:383:7: varOrTerm propertyListNotEmptyPath
 12770   
                     {
 12771  2884 
                     pushFollow(FOLLOW_varOrTerm_in_triplesSameSubjectPath3147);
 12772  2884 
                     varOrTerm277=varOrTerm();
 12773   
 
 12774  2884 
                     state._fsp--;
 12775   
 
 12776  2884 
                     stream_varOrTerm.add(varOrTerm277.getTree());
 12777   
 
 12778  2884 
                     pushFollow(FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3149);
 12779  2884 
                     propertyListNotEmptyPath278=propertyListNotEmptyPath();
 12780   
 
 12781  2884 
                     state._fsp--;
 12782   
 
 12783  2884 
                     stream_propertyListNotEmptyPath.add(propertyListNotEmptyPath278.getTree());
 12784   
 
 12785   
                     // AST REWRITE
 12786   
                     // elements: propertyListNotEmptyPath, varOrTerm
 12787   
                     // token labels:
 12788   
                     // rule labels: retval
 12789   
                     // token list labels:
 12790   
                     // rule list labels:
 12791   
                     // wildcard labels:
 12792  2884 
                     retval.tree = root_0;
 12793  2884 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12794   
 
 12795  2884 
                     root_0 = (Object)adaptor.nil();
 12796   
                     // 383:42: -> ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12797   
                     {
 12798   
                         // com\\googlecode\\sparkleg\\Sparql.g:383:45: ^( TRIPLES_SAME_SUBJECT ^( SUBJECT varOrTerm ) propertyListNotEmptyPath )
 12799   
                         {
 12800  2884 
                         Object root_1 = (Object)adaptor.nil();
 12801  2884 
                         root_1 = (Object)adaptor.becomeRoot(
 12802   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12803   
                         , root_1);
 12804   
 
 12805   
                         // com\\googlecode\\sparkleg\\Sparql.g:383:68: ^( SUBJECT varOrTerm )
 12806   
                         {
 12807  2884 
                         Object root_2 = (Object)adaptor.nil();
 12808  2884 
                         root_2 = (Object)adaptor.becomeRoot(
 12809   
                         (Object)adaptor.create(SUBJECT, "SUBJECT")
 12810   
                         , root_2);
 12811   
 
 12812  2884 
                         adaptor.addChild(root_2, stream_varOrTerm.nextTree());
 12813   
 
 12814  2884 
                         adaptor.addChild(root_1, root_2);
 12815   
                         }
 12816   
 
 12817  2884 
                         adaptor.addChild(root_1, stream_propertyListNotEmptyPath.nextTree());
 12818   
 
 12819  2884 
                         adaptor.addChild(root_0, root_1);
 12820   
                         }
 12821   
 
 12822   
                     }
 12823   
 
 12824   
 
 12825  2884 
                     retval.tree = root_0;
 12826   
 
 12827   
                     }
 12828  2884 
                     break;
 12829   
                 case 2 :
 12830   
                     // com\\googlecode\\sparkleg\\Sparql.g:384:7: triplesNode ( propertyListNotEmpty )?
 12831   
                     {
 12832  30 
                     pushFollow(FOLLOW_triplesNode_in_triplesSameSubjectPath3171);
 12833  30 
                     triplesNode279=triplesNode();
 12834   
 
 12835  30 
                     state._fsp--;
 12836   
 
 12837  30 
                     stream_triplesNode.add(triplesNode279.getTree());
 12838   
 
 12839   
                     // com\\googlecode\\sparkleg\\Sparql.g:384:19: ( propertyListNotEmpty )?
 12840  30 
                     int alt92=2;
 12841  30 
                     switch ( input.LA(1) ) {
 12842   
                         case A:
 12843   
                         case INVERSE:
 12844   
                         case IRI_REF:
 12845   
                         case NEGATION:
 12846   
                         case OPEN_BRACE:
 12847   
                         case PNAME_LN:
 12848   
                         case PNAME_NS:
 12849   
                         case VAR1:
 12850   
                         case VAR2:
 12851   
                             {
 12852  10 
                             alt92=1;
 12853   
                             }
 12854   
                             break;
 12855   
                     }
 12856   
 
 12857  30 
                     switch (alt92) {
 12858   
                         case 1 :
 12859   
                             // com\\googlecode\\sparkleg\\Sparql.g:384:19: propertyListNotEmpty
 12860   
                             {
 12861  10 
                             pushFollow(FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3173);
 12862  10 
                             propertyListNotEmpty280=propertyListNotEmpty();
 12863   
 
 12864  10 
                             state._fsp--;
 12865   
 
 12866  10 
                             stream_propertyListNotEmpty.add(propertyListNotEmpty280.getTree());
 12867   
 
 12868   
                             }
 12869   
                             break;
 12870   
 
 12871   
                     }
 12872   
 
 12873   
 
 12874   
                     // AST REWRITE
 12875   
                     // elements: propertyListNotEmpty, triplesNode
 12876   
                     // token labels:
 12877   
                     // rule labels: retval
 12878   
                     // token list labels:
 12879   
                     // rule list labels:
 12880   
                     // wildcard labels:
 12881  30 
                     retval.tree = root_0;
 12882  30 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 12883   
 
 12884  30 
                     root_0 = (Object)adaptor.nil();
 12885   
                     // 384:41: -> ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12886   
                     {
 12887   
                         // com\\googlecode\\sparkleg\\Sparql.g:384:44: ^( TRIPLES_SAME_SUBJECT triplesNode ( propertyListNotEmpty )? )
 12888   
                         {
 12889  30 
                         Object root_1 = (Object)adaptor.nil();
 12890  30 
                         root_1 = (Object)adaptor.becomeRoot(
 12891   
                         (Object)adaptor.create(TRIPLES_SAME_SUBJECT, "TRIPLES_SAME_SUBJECT")
 12892   
                         , root_1);
 12893   
 
 12894  30 
                         adaptor.addChild(root_1, stream_triplesNode.nextTree());
 12895   
 
 12896   
                         // com\\googlecode\\sparkleg\\Sparql.g:384:80: ( propertyListNotEmpty )?
 12897  30 
                         if ( stream_propertyListNotEmpty.hasNext() ) {
 12898  10 
                             adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 12899   
 
 12900   
                         }
 12901  30 
                         stream_propertyListNotEmpty.reset();
 12902   
 
 12903  30 
                         adaptor.addChild(root_0, root_1);
 12904   
                         }
 12905   
 
 12906   
                     }
 12907   
 
 12908   
 
 12909  30 
                     retval.tree = root_0;
 12910   
 
 12911   
                     }
 12912   
                     break;
 12913   
 
 12914   
             }
 12915  2914 
             retval.stop = input.LT(-1);
 12916   
 
 12917   
 
 12918  2914 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 12919  2914 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 12920   
 
 12921   
         }
 12922  0 
         catch (RecognitionException re) {
 12923  0 
             reportError(re);
 12924  0 
             recover(input,re);
 12925  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 12926   
 
 12927   
         }
 12928   
 
 12929  0 
         finally {
 12930   
                 // do for sure before leaving
 12931  2914 
         }
 12932  2914 
         return retval;
 12933   
     }
 12934   
     // $ANTLR end "triplesSameSubjectPath"
 12935   
 
 12936   
 
 12937  2884 
     public static class propertyListNotEmptyPath_return extends ParserRuleReturnScope {
 12938   
         Object tree;
 12939  2884 
         public Object getTree() { return tree; }
 12940   
     };
 12941   
 
 12942   
 
 12943   
     // $ANTLR start "propertyListNotEmptyPath"
 12944   
     // com\\googlecode\\sparkleg\\Sparql.g:387:1: propertyListNotEmptyPath : propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ ;
 12945   
     public final SparqlParser.propertyListNotEmptyPath_return propertyListNotEmptyPath() throws RecognitionException {
 12946  2884 
         SparqlParser.propertyListNotEmptyPath_return retval = new SparqlParser.propertyListNotEmptyPath_return();
 12947  2884 
         retval.start = input.LT(1);
 12948   
 
 12949   
 
 12950  2884 
         Object root_0 = null;
 12951   
 
 12952  2884 
         Token SEMICOLON282=null;
 12953  2884 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails281 =null;
 12954   
 
 12955  2884 
         SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails283 =null;
 12956   
 
 12957   
 
 12958  2884 
         Object SEMICOLON282_tree=null;
 12959  2884 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 12960  2884 
         RewriteRuleSubtreeStream stream_propertyListNotEmptyDetails=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmptyDetails");
 12961   
         try {
 12962   
             // com\\googlecode\\sparkleg\\Sparql.g:388:5: ( propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )* -> ( propertyListNotEmptyDetails )+ )
 12963   
             // com\\googlecode\\sparkleg\\Sparql.g:388:7: propertyListNotEmptyDetails ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12964   
             {
 12965  2884 
             pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3205);
 12966  2884 
             propertyListNotEmptyDetails281=propertyListNotEmptyDetails();
 12967   
 
 12968  2884 
             state._fsp--;
 12969   
 
 12970  2884 
             stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails281.getTree());
 12971   
 
 12972   
             // com\\googlecode\\sparkleg\\Sparql.g:388:35: ( SEMICOLON ( propertyListNotEmptyDetails )? )*
 12973   
             loop95:
 12974   
             do {
 12975  3086 
                 int alt95=2;
 12976  3086 
                 switch ( input.LA(1) ) {
 12977   
                 case SEMICOLON:
 12978   
                     {
 12979  202 
                     alt95=1;
 12980   
                     }
 12981   
                     break;
 12982   
 
 12983   
                 }
 12984   
 
 12985  3086 
                 switch (alt95) {
 12986   
                     case 1 :
 12987   
                         // com\\googlecode\\sparkleg\\Sparql.g:388:36: SEMICOLON ( propertyListNotEmptyDetails )?
 12988   
                         {
 12989  202 
                         SEMICOLON282=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3208);
 12990  202 
                         stream_SEMICOLON.add(SEMICOLON282);
 12991   
 
 12992   
 
 12993   
                         // com\\googlecode\\sparkleg\\Sparql.g:388:46: ( propertyListNotEmptyDetails )?
 12994  202 
                         int alt94=2;
 12995  202 
                         switch ( input.LA(1) ) {
 12996   
                             case A:
 12997   
                             case INVERSE:
 12998   
                             case IRI_REF:
 12999   
                             case NEGATION:
 13000   
                             case OPEN_BRACE:
 13001   
                             case PNAME_LN:
 13002   
                             case PNAME_NS:
 13003   
                             case VAR1:
 13004   
                             case VAR2:
 13005   
                                 {
 13006  198 
                                 alt94=1;
 13007   
                                 }
 13008   
                                 break;
 13009   
                         }
 13010   
 
 13011  202 
                         switch (alt94) {
 13012   
                             case 1 :
 13013   
                                 // com\\googlecode\\sparkleg\\Sparql.g:388:46: propertyListNotEmptyDetails
 13014   
                                 {
 13015  198 
                                 pushFollow(FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3210);
 13016  198 
                                 propertyListNotEmptyDetails283=propertyListNotEmptyDetails();
 13017   
 
 13018  198 
                                 state._fsp--;
 13019   
 
 13020  198 
                                 stream_propertyListNotEmptyDetails.add(propertyListNotEmptyDetails283.getTree());
 13021   
 
 13022   
                                 }
 13023   
                                 break;
 13024   
 
 13025   
                         }
 13026   
 
 13027   
 
 13028   
                         }
 13029  202 
                         break;
 13030   
 
 13031   
                     default :
 13032  2884 
                         break loop95;
 13033   
                 }
 13034  202 
             } while (true);
 13035   
 
 13036   
 
 13037   
             // AST REWRITE
 13038   
             // elements: propertyListNotEmptyDetails
 13039   
             // token labels:
 13040   
             // rule labels: retval
 13041   
             // token list labels:
 13042   
             // rule list labels:
 13043   
             // wildcard labels:
 13044  2884 
             retval.tree = root_0;
 13045  2884 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13046   
 
 13047  2884 
             root_0 = (Object)adaptor.nil();
 13048   
             // 388:77: -> ( propertyListNotEmptyDetails )+
 13049   
             {
 13050  2884 
                 if ( !(stream_propertyListNotEmptyDetails.hasNext()) ) {
 13051  0 
                     throw new RewriteEarlyExitException();
 13052   
                 }
 13053  5966 
                 while ( stream_propertyListNotEmptyDetails.hasNext() ) {
 13054  3082 
                     adaptor.addChild(root_0, stream_propertyListNotEmptyDetails.nextTree());
 13055   
 
 13056   
                 }
 13057  2884 
                 stream_propertyListNotEmptyDetails.reset();
 13058   
 
 13059   
             }
 13060   
 
 13061   
 
 13062  2884 
             retval.tree = root_0;
 13063   
 
 13064   
             }
 13065   
 
 13066  2884 
             retval.stop = input.LT(-1);
 13067   
 
 13068   
 
 13069  2884 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13070  2884 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13071   
 
 13072   
         }
 13073  0 
         catch (RecognitionException re) {
 13074  0 
             reportError(re);
 13075  0 
             recover(input,re);
 13076  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13077   
 
 13078   
         }
 13079   
 
 13080  0 
         finally {
 13081   
                 // do for sure before leaving
 13082  2884 
         }
 13083  2884 
         return retval;
 13084   
     }
 13085   
     // $ANTLR end "propertyListNotEmptyPath"
 13086   
 
 13087   
 
 13088  3354 
     public static class propertyListNotEmptyDetails_return extends ParserRuleReturnScope {
 13089   
         Object tree;
 13090  3354 
         public Object getTree() { return tree; }
 13091   
     };
 13092   
 
 13093   
 
 13094   
     // $ANTLR start "propertyListNotEmptyDetails"
 13095   
     // com\\googlecode\\sparkleg\\Sparql.g:391:1: propertyListNotEmptyDetails : verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) ;
 13096   
     public final SparqlParser.propertyListNotEmptyDetails_return propertyListNotEmptyDetails() throws RecognitionException {
 13097  3354 
         SparqlParser.propertyListNotEmptyDetails_return retval = new SparqlParser.propertyListNotEmptyDetails_return();
 13098  3354 
         retval.start = input.LT(1);
 13099   
 
 13100   
 
 13101  3354 
         Object root_0 = null;
 13102   
 
 13103  3354 
         SparqlParser.verbSimpleOrPath_return verbSimpleOrPath284 =null;
 13104   
 
 13105  3354 
         SparqlParser.objectList_return objectList285 =null;
 13106   
 
 13107   
 
 13108  3354 
         RewriteRuleSubtreeStream stream_verbSimpleOrPath=new RewriteRuleSubtreeStream(adaptor,"rule verbSimpleOrPath");
 13109  3354 
         RewriteRuleSubtreeStream stream_objectList=new RewriteRuleSubtreeStream(adaptor,"rule objectList");
 13110   
         try {
 13111   
             // com\\googlecode\\sparkleg\\Sparql.g:392:5: ( verbSimpleOrPath objectList -> ^( PREDICATE verbSimpleOrPath objectList ) )
 13112   
             // com\\googlecode\\sparkleg\\Sparql.g:392:7: verbSimpleOrPath objectList
 13113   
             {
 13114  3354 
             pushFollow(FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3237);
 13115  3354 
             verbSimpleOrPath284=verbSimpleOrPath();
 13116   
 
 13117  3354 
             state._fsp--;
 13118   
 
 13119  3354 
             stream_verbSimpleOrPath.add(verbSimpleOrPath284.getTree());
 13120   
 
 13121  3354 
             pushFollow(FOLLOW_objectList_in_propertyListNotEmptyDetails3239);
 13122  3354 
             objectList285=objectList();
 13123   
 
 13124  3354 
             state._fsp--;
 13125   
 
 13126  3354 
             stream_objectList.add(objectList285.getTree());
 13127   
 
 13128   
             // AST REWRITE
 13129   
             // elements: verbSimpleOrPath, objectList
 13130   
             // token labels:
 13131   
             // rule labels: retval
 13132   
             // token list labels:
 13133   
             // rule list labels:
 13134   
             // wildcard labels:
 13135  3354 
             retval.tree = root_0;
 13136  3354 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13137   
 
 13138  3354 
             root_0 = (Object)adaptor.nil();
 13139   
             // 392:35: -> ^( PREDICATE verbSimpleOrPath objectList )
 13140   
             {
 13141   
                 // com\\googlecode\\sparkleg\\Sparql.g:392:38: ^( PREDICATE verbSimpleOrPath objectList )
 13142   
                 {
 13143  3354 
                 Object root_1 = (Object)adaptor.nil();
 13144  3354 
                 root_1 = (Object)adaptor.becomeRoot(
 13145   
                 (Object)adaptor.create(PREDICATE, "PREDICATE")
 13146   
                 , root_1);
 13147   
 
 13148  3354 
                 adaptor.addChild(root_1, stream_verbSimpleOrPath.nextTree());
 13149   
 
 13150  3354 
                 adaptor.addChild(root_1, stream_objectList.nextTree());
 13151   
 
 13152  3354 
                 adaptor.addChild(root_0, root_1);
 13153   
                 }
 13154   
 
 13155   
             }
 13156   
 
 13157   
 
 13158  3354 
             retval.tree = root_0;
 13159   
 
 13160   
             }
 13161   
 
 13162  3354 
             retval.stop = input.LT(-1);
 13163   
 
 13164   
 
 13165  3354 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13166  3354 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13167   
 
 13168   
         }
 13169  0 
         catch (RecognitionException re) {
 13170  0 
             reportError(re);
 13171  0 
             recover(input,re);
 13172  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13173   
 
 13174   
         }
 13175   
 
 13176  0 
         finally {
 13177   
                 // do for sure before leaving
 13178  3354 
         }
 13179  3354 
         return retval;
 13180   
     }
 13181   
     // $ANTLR end "propertyListNotEmptyDetails"
 13182   
 
 13183   
 
 13184  3354 
     public static class verbSimpleOrPath_return extends ParserRuleReturnScope {
 13185   
         Object tree;
 13186  3354 
         public Object getTree() { return tree; }
 13187   
     };
 13188   
 
 13189   
 
 13190   
     // $ANTLR start "verbSimpleOrPath"
 13191   
     // com\\googlecode\\sparkleg\\Sparql.g:395:1: verbSimpleOrPath : ( verbPath | verbSimple );
 13192   
     public final SparqlParser.verbSimpleOrPath_return verbSimpleOrPath() throws RecognitionException {
 13193  3354 
         SparqlParser.verbSimpleOrPath_return retval = new SparqlParser.verbSimpleOrPath_return();
 13194  3354 
         retval.start = input.LT(1);
 13195   
 
 13196   
 
 13197  3354 
         Object root_0 = null;
 13198   
 
 13199  3354 
         SparqlParser.verbPath_return verbPath286 =null;
 13200   
 
 13201  3354 
         SparqlParser.verbSimple_return verbSimple287 =null;
 13202   
 
 13203   
 
 13204   
 
 13205   
         try {
 13206   
             // com\\googlecode\\sparkleg\\Sparql.g:396:5: ( verbPath | verbSimple )
 13207  3354 
             int alt96=2;
 13208  3354 
             switch ( input.LA(1) ) {
 13209   
             case A:
 13210   
             case INVERSE:
 13211   
             case IRI_REF:
 13212   
             case NEGATION:
 13213   
             case OPEN_BRACE:
 13214   
             case PNAME_LN:
 13215   
             case PNAME_NS:
 13216   
                 {
 13217  2666 
                 alt96=1;
 13218   
                 }
 13219  2666 
                 break;
 13220   
             case VAR1:
 13221   
             case VAR2:
 13222   
                 {
 13223  688 
                 alt96=2;
 13224   
                 }
 13225  688 
                 break;
 13226   
             default:
 13227  0 
                 NoViableAltException nvae =
 13228   
                     new NoViableAltException("", 96, 0, input);
 13229   
 
 13230  0 
                 throw nvae;
 13231   
 
 13232   
             }
 13233   
 
 13234  3354 
             switch (alt96) {
 13235   
                 case 1 :
 13236   
                     // com\\googlecode\\sparkleg\\Sparql.g:396:7: verbPath
 13237   
                     {
 13238  2666 
                     root_0 = (Object)adaptor.nil();
 13239   
 
 13240   
 
 13241  2666 
                     pushFollow(FOLLOW_verbPath_in_verbSimpleOrPath3269);
 13242  2666 
                     verbPath286=verbPath();
 13243   
 
 13244  2666 
                     state._fsp--;
 13245   
 
 13246  2666 
                     adaptor.addChild(root_0, verbPath286.getTree());
 13247   
 
 13248   
                     }
 13249  2666 
                     break;
 13250   
                 case 2 :
 13251   
                     // com\\googlecode\\sparkleg\\Sparql.g:397:7: verbSimple
 13252   
                     {
 13253  688 
                     root_0 = (Object)adaptor.nil();
 13254   
 
 13255   
 
 13256  688 
                     pushFollow(FOLLOW_verbSimple_in_verbSimpleOrPath3277);
 13257  688 
                     verbSimple287=verbSimple();
 13258   
 
 13259  688 
                     state._fsp--;
 13260   
 
 13261  688 
                     adaptor.addChild(root_0, verbSimple287.getTree());
 13262   
 
 13263   
                     }
 13264   
                     break;
 13265   
 
 13266   
             }
 13267  3354 
             retval.stop = input.LT(-1);
 13268   
 
 13269   
 
 13270  3354 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13271  3354 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13272   
 
 13273   
         }
 13274  0 
         catch (RecognitionException re) {
 13275  0 
             reportError(re);
 13276  0 
             recover(input,re);
 13277  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13278   
 
 13279   
         }
 13280   
 
 13281  0 
         finally {
 13282   
                 // do for sure before leaving
 13283  3354 
         }
 13284  3354 
         return retval;
 13285   
     }
 13286   
     // $ANTLR end "verbSimpleOrPath"
 13287   
 
 13288   
 
 13289  2666 
     public static class verbPath_return extends ParserRuleReturnScope {
 13290   
         Object tree;
 13291  2666 
         public Object getTree() { return tree; }
 13292   
     };
 13293   
 
 13294   
 
 13295   
     // $ANTLR start "verbPath"
 13296   
     // com\\googlecode\\sparkleg\\Sparql.g:400:1: verbPath : path ;
 13297   
     public final SparqlParser.verbPath_return verbPath() throws RecognitionException {
 13298  2666 
         SparqlParser.verbPath_return retval = new SparqlParser.verbPath_return();
 13299  2666 
         retval.start = input.LT(1);
 13300   
 
 13301   
 
 13302  2666 
         Object root_0 = null;
 13303   
 
 13304  2666 
         SparqlParser.path_return path288 =null;
 13305   
 
 13306   
 
 13307   
 
 13308   
         try {
 13309   
             // com\\googlecode\\sparkleg\\Sparql.g:401:5: ( path )
 13310   
             // com\\googlecode\\sparkleg\\Sparql.g:401:7: path
 13311   
             {
 13312  2666 
             root_0 = (Object)adaptor.nil();
 13313   
 
 13314   
 
 13315  2666 
             pushFollow(FOLLOW_path_in_verbPath3296);
 13316  2666 
             path288=path();
 13317   
 
 13318  2666 
             state._fsp--;
 13319   
 
 13320  2666 
             adaptor.addChild(root_0, path288.getTree());
 13321   
 
 13322   
             }
 13323   
 
 13324  2666 
             retval.stop = input.LT(-1);
 13325   
 
 13326   
 
 13327  2666 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13328  2666 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13329   
 
 13330   
         }
 13331  0 
         catch (RecognitionException re) {
 13332  0 
             reportError(re);
 13333  0 
             recover(input,re);
 13334  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13335   
 
 13336   
         }
 13337   
 
 13338  0 
         finally {
 13339   
                 // do for sure before leaving
 13340  2666 
         }
 13341  2666 
         return retval;
 13342   
     }
 13343   
     // $ANTLR end "verbPath"
 13344   
 
 13345   
 
 13346  688 
     public static class verbSimple_return extends ParserRuleReturnScope {
 13347   
         Object tree;
 13348  688 
         public Object getTree() { return tree; }
 13349   
     };
 13350   
 
 13351   
 
 13352   
     // $ANTLR start "verbSimple"
 13353   
     // com\\googlecode\\sparkleg\\Sparql.g:404:1: verbSimple : var ;
 13354   
     public final SparqlParser.verbSimple_return verbSimple() throws RecognitionException {
 13355  688 
         SparqlParser.verbSimple_return retval = new SparqlParser.verbSimple_return();
 13356  688 
         retval.start = input.LT(1);
 13357   
 
 13358   
 
 13359  688 
         Object root_0 = null;
 13360   
 
 13361  688 
         SparqlParser.var_return var289 =null;
 13362   
 
 13363   
 
 13364   
 
 13365   
         try {
 13366   
             // com\\googlecode\\sparkleg\\Sparql.g:405:5: ( var )
 13367   
             // com\\googlecode\\sparkleg\\Sparql.g:405:7: var
 13368   
             {
 13369  688 
             root_0 = (Object)adaptor.nil();
 13370   
 
 13371   
 
 13372  688 
             pushFollow(FOLLOW_var_in_verbSimple3317);
 13373  688 
             var289=var();
 13374   
 
 13375  688 
             state._fsp--;
 13376   
 
 13377  688 
             adaptor.addChild(root_0, var289.getTree());
 13378   
 
 13379   
             }
 13380   
 
 13381  688 
             retval.stop = input.LT(-1);
 13382   
 
 13383   
 
 13384  688 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13385  688 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13386   
 
 13387   
         }
 13388  0 
         catch (RecognitionException re) {
 13389  0 
             reportError(re);
 13390  0 
             recover(input,re);
 13391  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13392   
 
 13393   
         }
 13394   
 
 13395  0 
         finally {
 13396   
                 // do for sure before leaving
 13397  688 
         }
 13398  688 
         return retval;
 13399   
     }
 13400   
     // $ANTLR end "verbSimple"
 13401   
 
 13402   
 
 13403  2686 
     public static class path_return extends ParserRuleReturnScope {
 13404   
         Object tree;
 13405  2686 
         public Object getTree() { return tree; }
 13406   
     };
 13407   
 
 13408   
 
 13409   
     // $ANTLR start "path"
 13410   
     // com\\googlecode\\sparkleg\\Sparql.g:408:1: path : pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) ;
 13411   
     public final SparqlParser.path_return path() throws RecognitionException {
 13412  2686 
         SparqlParser.path_return retval = new SparqlParser.path_return();
 13413  2686 
         retval.start = input.LT(1);
 13414   
 
 13415   
 
 13416  2686 
         Object root_0 = null;
 13417   
 
 13418  2686 
         Token PIPE291=null;
 13419  2686 
         SparqlParser.pathSequence_return pathSequence290 =null;
 13420   
 
 13421  2686 
         SparqlParser.pathSequence_return pathSequence292 =null;
 13422   
 
 13423   
 
 13424  2686 
         Object PIPE291_tree=null;
 13425  2686 
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 13426  2686 
         RewriteRuleSubtreeStream stream_pathSequence=new RewriteRuleSubtreeStream(adaptor,"rule pathSequence");
 13427   
         try {
 13428   
             // com\\googlecode\\sparkleg\\Sparql.g:409:5: ( pathSequence ( PIPE pathSequence )* -> ^( PATH ( pathSequence )+ ) )
 13429   
             // com\\googlecode\\sparkleg\\Sparql.g:409:7: pathSequence ( PIPE pathSequence )*
 13430   
             {
 13431  2686 
             pushFollow(FOLLOW_pathSequence_in_path3339);
 13432  2686 
             pathSequence290=pathSequence();
 13433   
 
 13434  2686 
             state._fsp--;
 13435   
 
 13436  2686 
             stream_pathSequence.add(pathSequence290.getTree());
 13437   
 
 13438   
             // com\\googlecode\\sparkleg\\Sparql.g:409:20: ( PIPE pathSequence )*
 13439   
             loop97:
 13440   
             do {
 13441  2706 
                 int alt97=2;
 13442  2706 
                 switch ( input.LA(1) ) {
 13443   
                 case PIPE:
 13444   
                     {
 13445  20 
                     alt97=1;
 13446   
                     }
 13447   
                     break;
 13448   
 
 13449   
                 }
 13450   
 
 13451  2706 
                 switch (alt97) {
 13452   
                     case 1 :
 13453   
                         // com\\googlecode\\sparkleg\\Sparql.g:409:21: PIPE pathSequence
 13454   
                         {
 13455  20 
                         PIPE291=(Token)match(input,PIPE,FOLLOW_PIPE_in_path3342);
 13456  20 
                         stream_PIPE.add(PIPE291);
 13457   
 
 13458   
 
 13459  20 
                         pushFollow(FOLLOW_pathSequence_in_path3344);
 13460  20 
                         pathSequence292=pathSequence();
 13461   
 
 13462  20 
                         state._fsp--;
 13463   
 
 13464  20 
                         stream_pathSequence.add(pathSequence292.getTree());
 13465   
 
 13466   
                         }
 13467  20 
                         break;
 13468   
 
 13469   
                     default :
 13470  2686 
                         break loop97;
 13471   
                 }
 13472  20 
             } while (true);
 13473   
 
 13474   
 
 13475   
             // AST REWRITE
 13476   
             // elements: pathSequence
 13477   
             // token labels:
 13478   
             // rule labels: retval
 13479   
             // token list labels:
 13480   
             // rule list labels:
 13481   
             // wildcard labels:
 13482  2686 
             retval.tree = root_0;
 13483  2686 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13484   
 
 13485  2686 
             root_0 = (Object)adaptor.nil();
 13486   
             // 409:41: -> ^( PATH ( pathSequence )+ )
 13487   
             {
 13488   
                 // com\\googlecode\\sparkleg\\Sparql.g:409:44: ^( PATH ( pathSequence )+ )
 13489   
                 {
 13490  2686 
                 Object root_1 = (Object)adaptor.nil();
 13491  2686 
                 root_1 = (Object)adaptor.becomeRoot(
 13492   
                 (Object)adaptor.create(PATH, "PATH")
 13493   
                 , root_1);
 13494   
 
 13495  2686 
                 if ( !(stream_pathSequence.hasNext()) ) {
 13496  0 
                     throw new RewriteEarlyExitException();
 13497   
                 }
 13498  5392 
                 while ( stream_pathSequence.hasNext() ) {
 13499  2706 
                     adaptor.addChild(root_1, stream_pathSequence.nextTree());
 13500   
 
 13501   
                 }
 13502  2686 
                 stream_pathSequence.reset();
 13503   
 
 13504  2686 
                 adaptor.addChild(root_0, root_1);
 13505   
                 }
 13506   
 
 13507   
             }
 13508   
 
 13509   
 
 13510  2686 
             retval.tree = root_0;
 13511   
 
 13512   
             }
 13513   
 
 13514  2686 
             retval.stop = input.LT(-1);
 13515   
 
 13516   
 
 13517  2686 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13518  2686 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13519   
 
 13520   
         }
 13521  0 
         catch (RecognitionException re) {
 13522  0 
             reportError(re);
 13523  0 
             recover(input,re);
 13524  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13525   
 
 13526   
         }
 13527   
 
 13528  0 
         finally {
 13529   
                 // do for sure before leaving
 13530  2686 
         }
 13531  2686 
         return retval;
 13532   
     }
 13533   
     // $ANTLR end "path"
 13534   
 
 13535   
 
 13536  2706 
     public static class pathSequence_return extends ParserRuleReturnScope {
 13537   
         Object tree;
 13538  2706 
         public Object getTree() { return tree; }
 13539   
     };
 13540   
 
 13541   
 
 13542   
     // $ANTLR start "pathSequence"
 13543   
     // com\\googlecode\\sparkleg\\Sparql.g:412:1: pathSequence : pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) ;
 13544   
     public final SparqlParser.pathSequence_return pathSequence() throws RecognitionException {
 13545  2706 
         SparqlParser.pathSequence_return retval = new SparqlParser.pathSequence_return();
 13546  2706 
         retval.start = input.LT(1);
 13547   
 
 13548   
 
 13549  2706 
         Object root_0 = null;
 13550   
 
 13551  2706 
         Token DIVIDE294=null;
 13552  2706 
         SparqlParser.pathEltOrInverse_return pathEltOrInverse293 =null;
 13553   
 
 13554  2706 
         SparqlParser.pathEltOrInverse_return pathEltOrInverse295 =null;
 13555   
 
 13556   
 
 13557  2706 
         Object DIVIDE294_tree=null;
 13558  2706 
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 13559  2706 
         RewriteRuleSubtreeStream stream_pathEltOrInverse=new RewriteRuleSubtreeStream(adaptor,"rule pathEltOrInverse");
 13560   
         try {
 13561   
             // com\\googlecode\\sparkleg\\Sparql.g:413:5: ( pathEltOrInverse ( DIVIDE pathEltOrInverse )* -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ ) )
 13562   
             // com\\googlecode\\sparkleg\\Sparql.g:413:7: pathEltOrInverse ( DIVIDE pathEltOrInverse )*
 13563   
             {
 13564  2706 
             pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3373);
 13565  2706 
             pathEltOrInverse293=pathEltOrInverse();
 13566   
 
 13567  2706 
             state._fsp--;
 13568   
 
 13569  2706 
             stream_pathEltOrInverse.add(pathEltOrInverse293.getTree());
 13570   
 
 13571   
             // com\\googlecode\\sparkleg\\Sparql.g:413:24: ( DIVIDE pathEltOrInverse )*
 13572   
             loop98:
 13573   
             do {
 13574  2770 
                 int alt98=2;
 13575  2770 
                 switch ( input.LA(1) ) {
 13576   
                 case DIVIDE:
 13577   
                     {
 13578  64 
                     alt98=1;
 13579   
                     }
 13580   
                     break;
 13581   
 
 13582   
                 }
 13583   
 
 13584  2770 
                 switch (alt98) {
 13585   
                     case 1 :
 13586   
                         // com\\googlecode\\sparkleg\\Sparql.g:413:25: DIVIDE pathEltOrInverse
 13587   
                         {
 13588  64 
                         DIVIDE294=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_pathSequence3376);
 13589  64 
                         stream_DIVIDE.add(DIVIDE294);
 13590   
 
 13591   
 
 13592  64 
                         pushFollow(FOLLOW_pathEltOrInverse_in_pathSequence3378);
 13593  64 
                         pathEltOrInverse295=pathEltOrInverse();
 13594   
 
 13595  64 
                         state._fsp--;
 13596   
 
 13597  64 
                         stream_pathEltOrInverse.add(pathEltOrInverse295.getTree());
 13598   
 
 13599   
                         }
 13600  64 
                         break;
 13601   
 
 13602   
                     default :
 13603  2706 
                         break loop98;
 13604   
                 }
 13605  64 
             } while (true);
 13606   
 
 13607   
 
 13608   
             // AST REWRITE
 13609   
             // elements: pathEltOrInverse
 13610   
             // token labels:
 13611   
             // rule labels: retval
 13612   
             // token list labels:
 13613   
             // rule list labels:
 13614   
             // wildcard labels:
 13615  2706 
             retval.tree = root_0;
 13616  2706 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 13617   
 
 13618  2706 
             root_0 = (Object)adaptor.nil();
 13619   
             // 413:51: -> ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13620   
             {
 13621   
                 // com\\googlecode\\sparkleg\\Sparql.g:413:54: ^( PATH_SEQUENCE ( pathEltOrInverse )+ )
 13622   
                 {
 13623  2706 
                 Object root_1 = (Object)adaptor.nil();
 13624  2706 
                 root_1 = (Object)adaptor.becomeRoot(
 13625   
                 (Object)adaptor.create(PATH_SEQUENCE, "PATH_SEQUENCE")
 13626   
                 , root_1);
 13627   
 
 13628  2706 
                 if ( !(stream_pathEltOrInverse.hasNext()) ) {
 13629  0 
                     throw new RewriteEarlyExitException();
 13630   
                 }
 13631  5476 
                 while ( stream_pathEltOrInverse.hasNext() ) {
 13632  2770 
                     adaptor.addChild(root_1, stream_pathEltOrInverse.nextTree());
 13633   
 
 13634   
                 }
 13635  2706 
                 stream_pathEltOrInverse.reset();
 13636   
 
 13637  2706 
                 adaptor.addChild(root_0, root_1);
 13638   
                 }
 13639   
 
 13640   
             }
 13641   
 
 13642   
 
 13643  2706 
             retval.tree = root_0;
 13644   
 
 13645   
             }
 13646   
 
 13647  2706 
             retval.stop = input.LT(-1);
 13648   
 
 13649   
 
 13650  2706 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13651  2706 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13652   
 
 13653   
         }
 13654  0 
         catch (RecognitionException re) {
 13655  0 
             reportError(re);
 13656  0 
             recover(input,re);
 13657  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13658   
 
 13659   
         }
 13660   
 
 13661  0 
         finally {
 13662   
                 // do for sure before leaving
 13663  2706 
         }
 13664  2706 
         return retval;
 13665   
     }
 13666   
     // $ANTLR end "pathSequence"
 13667   
 
 13668   
 
 13669  2770 
     public static class pathEltOrInverse_return extends ParserRuleReturnScope {
 13670   
         Object tree;
 13671  2770 
         public Object getTree() { return tree; }
 13672   
     };
 13673   
 
 13674   
 
 13675   
     // $ANTLR start "pathEltOrInverse"
 13676   
     // com\\googlecode\\sparkleg\\Sparql.g:416:1: pathEltOrInverse : ( INVERSE )? pathElt ;
 13677   
     public final SparqlParser.pathEltOrInverse_return pathEltOrInverse() throws RecognitionException {
 13678  2770 
         SparqlParser.pathEltOrInverse_return retval = new SparqlParser.pathEltOrInverse_return();
 13679  2770 
         retval.start = input.LT(1);
 13680   
 
 13681   
 
 13682  2770 
         Object root_0 = null;
 13683   
 
 13684  2770 
         Token INVERSE296=null;
 13685  2770 
         SparqlParser.pathElt_return pathElt297 =null;
 13686   
 
 13687   
 
 13688  2770 
         Object INVERSE296_tree=null;
 13689   
 
 13690   
         try {
 13691   
             // com\\googlecode\\sparkleg\\Sparql.g:417:5: ( ( INVERSE )? pathElt )
 13692   
             // com\\googlecode\\sparkleg\\Sparql.g:417:7: ( INVERSE )? pathElt
 13693   
             {
 13694  2770 
             root_0 = (Object)adaptor.nil();
 13695   
 
 13696   
 
 13697   
             // com\\googlecode\\sparkleg\\Sparql.g:417:7: ( INVERSE )?
 13698  2770 
             int alt99=2;
 13699  2770 
             switch ( input.LA(1) ) {
 13700   
                 case INVERSE:
 13701   
                     {
 13702  12 
                     alt99=1;
 13703   
                     }
 13704   
                     break;
 13705   
             }
 13706   
 
 13707  2770 
             switch (alt99) {
 13708   
                 case 1 :
 13709   
                     // com\\googlecode\\sparkleg\\Sparql.g:417:7: INVERSE
 13710   
                     {
 13711  12 
                     INVERSE296=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathEltOrInverse3406);
 13712  12 
                     INVERSE296_tree =
 13713   
                     (Object)adaptor.create(INVERSE296)
 13714   
                     ;
 13715  12 
                     adaptor.addChild(root_0, INVERSE296_tree);
 13716   
 
 13717   
 
 13718   
                     }
 13719   
                     break;
 13720   
 
 13721   
             }
 13722   
 
 13723   
 
 13724  2770 
             pushFollow(FOLLOW_pathElt_in_pathEltOrInverse3409);
 13725  2770 
             pathElt297=pathElt();
 13726   
 
 13727  2770 
             state._fsp--;
 13728   
 
 13729  2770 
             adaptor.addChild(root_0, pathElt297.getTree());
 13730   
 
 13731   
             }
 13732   
 
 13733  2770 
             retval.stop = input.LT(-1);
 13734   
 
 13735   
 
 13736  2770 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13737  2770 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13738   
 
 13739   
         }
 13740  0 
         catch (RecognitionException re) {
 13741  0 
             reportError(re);
 13742  0 
             recover(input,re);
 13743  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13744   
 
 13745   
         }
 13746   
 
 13747  0 
         finally {
 13748   
                 // do for sure before leaving
 13749  2770 
         }
 13750  2770 
         return retval;
 13751   
     }
 13752   
     // $ANTLR end "pathEltOrInverse"
 13753   
 
 13754   
 
 13755  2770 
     public static class pathElt_return extends ParserRuleReturnScope {
 13756   
         Object tree;
 13757  2770 
         public Object getTree() { return tree; }
 13758   
     };
 13759   
 
 13760   
 
 13761   
     // $ANTLR start "pathElt"
 13762   
     // com\\googlecode\\sparkleg\\Sparql.g:420:1: pathElt : pathPrimary ( pathMod )? ;
 13763   
     public final SparqlParser.pathElt_return pathElt() throws RecognitionException {
 13764  2770 
         SparqlParser.pathElt_return retval = new SparqlParser.pathElt_return();
 13765  2770 
         retval.start = input.LT(1);
 13766   
 
 13767   
 
 13768  2770 
         Object root_0 = null;
 13769   
 
 13770  2770 
         SparqlParser.pathPrimary_return pathPrimary298 =null;
 13771   
 
 13772  2770 
         SparqlParser.pathMod_return pathMod299 =null;
 13773   
 
 13774   
 
 13775   
 
 13776   
         try {
 13777   
             // com\\googlecode\\sparkleg\\Sparql.g:421:5: ( pathPrimary ( pathMod )? )
 13778   
             // com\\googlecode\\sparkleg\\Sparql.g:421:7: pathPrimary ( pathMod )?
 13779   
             {
 13780  2770 
             root_0 = (Object)adaptor.nil();
 13781   
 
 13782   
 
 13783  2770 
             pushFollow(FOLLOW_pathPrimary_in_pathElt3437);
 13784  2770 
             pathPrimary298=pathPrimary();
 13785   
 
 13786  2770 
             state._fsp--;
 13787   
 
 13788  2770 
             adaptor.addChild(root_0, pathPrimary298.getTree());
 13789   
 
 13790   
             // com\\googlecode\\sparkleg\\Sparql.g:421:19: ( pathMod )?
 13791  2770 
             int alt100=2;
 13792  2770 
             switch ( input.LA(1) ) {
 13793   
                 case ASTERISK:
 13794   
                 case OPEN_CURLY_BRACE:
 13795   
                 case PLUS:
 13796   
                 case QUESTION_MARK:
 13797   
                     {
 13798  66 
                     alt100=1;
 13799   
                     }
 13800   
                     break;
 13801   
             }
 13802   
 
 13803  2770 
             switch (alt100) {
 13804   
                 case 1 :
 13805   
                     // com\\googlecode\\sparkleg\\Sparql.g:421:19: pathMod
 13806   
                     {
 13807  66 
                     pushFollow(FOLLOW_pathMod_in_pathElt3439);
 13808  66 
                     pathMod299=pathMod();
 13809   
 
 13810  66 
                     state._fsp--;
 13811   
 
 13812  66 
                     adaptor.addChild(root_0, pathMod299.getTree());
 13813   
 
 13814   
                     }
 13815   
                     break;
 13816   
 
 13817   
             }
 13818   
 
 13819   
 
 13820   
             }
 13821   
 
 13822  2770 
             retval.stop = input.LT(-1);
 13823   
 
 13824   
 
 13825  2770 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 13826  2770 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 13827   
 
 13828   
         }
 13829  0 
         catch (RecognitionException re) {
 13830  0 
             reportError(re);
 13831  0 
             recover(input,re);
 13832  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 13833   
 
 13834   
         }
 13835   
 
 13836  0 
         finally {
 13837   
                 // do for sure before leaving
 13838  2770 
         }
 13839  2770 
         return retval;
 13840   
     }
 13841   
     // $ANTLR end "pathElt"
 13842   
 
 13843   
 
 13844  66 
     public static class pathMod_return extends ParserRuleReturnScope {
 13845   
         Object tree;
 13846  66 
         public Object getTree() { return tree; }
 13847   
     };
 13848   
 
 13849   
 
 13850   
     // $ANTLR start "pathMod"
 13851   
     // com\\googlecode\\sparkleg\\Sparql.g:424:1: pathMod : ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) ;
 13852   
     public final SparqlParser.pathMod_return pathMod() throws RecognitionException {
 13853  66 
         SparqlParser.pathMod_return retval = new SparqlParser.pathMod_return();
 13854  66 
         retval.start = input.LT(1);
 13855   
 
 13856   
 
 13857  66 
         Object root_0 = null;
 13858   
 
 13859  66 
         Token ASTERISK300=null;
 13860  66 
         Token QUESTION_MARK301=null;
 13861  66 
         Token PLUS302=null;
 13862  66 
         Token OPEN_CURLY_BRACE303=null;
 13863  66 
         Token INTEGER304=null;
 13864  66 
         Token COMMA305=null;
 13865  66 
         Token CLOSE_CURLY_BRACE306=null;
 13866  66 
         Token INTEGER307=null;
 13867  66 
         Token CLOSE_CURLY_BRACE308=null;
 13868  66 
         Token CLOSE_CURLY_BRACE309=null;
 13869  66 
         Token COMMA310=null;
 13870  66 
         Token INTEGER311=null;
 13871  66 
         Token CLOSE_CURLY_BRACE312=null;
 13872   
 
 13873  66 
         Object ASTERISK300_tree=null;
 13874  66 
         Object QUESTION_MARK301_tree=null;
 13875  66 
         Object PLUS302_tree=null;
 13876  66 
         Object OPEN_CURLY_BRACE303_tree=null;
 13877  66 
         Object INTEGER304_tree=null;
 13878  66 
         Object COMMA305_tree=null;
 13879  66 
         Object CLOSE_CURLY_BRACE306_tree=null;
 13880  66 
         Object INTEGER307_tree=null;
 13881  66 
         Object CLOSE_CURLY_BRACE308_tree=null;
 13882  66 
         Object CLOSE_CURLY_BRACE309_tree=null;
 13883  66 
         Object COMMA310_tree=null;
 13884  66 
         Object INTEGER311_tree=null;
 13885  66 
         Object CLOSE_CURLY_BRACE312_tree=null;
 13886   
 
 13887   
         try {
 13888   
             // com\\googlecode\\sparkleg\\Sparql.g:425:5: ( ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) ) )
 13889   
             // com\\googlecode\\sparkleg\\Sparql.g:425:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13890   
             {
 13891  66 
             root_0 = (Object)adaptor.nil();
 13892   
 
 13893   
 
 13894   
             // com\\googlecode\\sparkleg\\Sparql.g:425:7: ( ASTERISK | QUESTION_MARK | PLUS | OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE ) )
 13895  66 
             int alt104=4;
 13896  66 
             switch ( input.LA(1) ) {
 13897   
             case ASTERISK:
 13898   
                 {
 13899  18 
                 alt104=1;
 13900   
                 }
 13901  18 
                 break;
 13902   
             case QUESTION_MARK:
 13903   
                 {
 13904  2 
                 alt104=2;
 13905   
                 }
 13906  2 
                 break;
 13907   
             case PLUS:
 13908   
                 {
 13909  16 
                 alt104=3;
 13910   
                 }
 13911  16 
                 break;
 13912   
             case OPEN_CURLY_BRACE:
 13913   
                 {
 13914  30 
                 alt104=4;
 13915   
                 }
 13916  30 
                 break;
 13917   
             default:
 13918  0 
                 NoViableAltException nvae =
 13919   
                     new NoViableAltException("", 104, 0, input);
 13920   
 
 13921  0 
                 throw nvae;
 13922   
 
 13923   
             }
 13924   
 
 13925  66 
             switch (alt104) {
 13926   
                 case 1 :
 13927   
                     // com\\googlecode\\sparkleg\\Sparql.g:425:8: ASTERISK
 13928   
                     {
 13929  18 
                     ASTERISK300=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_pathMod3458);
 13930  18 
                     ASTERISK300_tree =
 13931   
                     (Object)adaptor.create(ASTERISK300)
 13932   
                     ;
 13933  18 
                     adaptor.addChild(root_0, ASTERISK300_tree);
 13934   
 
 13935   
 
 13936   
                     }
 13937  18 
                     break;
 13938   
                 case 2 :
 13939   
                     // com\\googlecode\\sparkleg\\Sparql.g:425:19: QUESTION_MARK
 13940   
                     {
 13941  2 
                     QUESTION_MARK301=(Token)match(input,QUESTION_MARK,FOLLOW_QUESTION_MARK_in_pathMod3462);
 13942  2 
                     QUESTION_MARK301_tree =
 13943   
                     (Object)adaptor.create(QUESTION_MARK301)
 13944   
                     ;
 13945  2 
                     adaptor.addChild(root_0, QUESTION_MARK301_tree);
 13946   
 
 13947   
 
 13948   
                     }
 13949  2 
                     break;
 13950   
                 case 3 :
 13951   
                     // com\\googlecode\\sparkleg\\Sparql.g:425:35: PLUS
 13952   
                     {
 13953  16 
                     PLUS302=(Token)match(input,PLUS,FOLLOW_PLUS_in_pathMod3466);
 13954  16 
                     PLUS302_tree =
 13955   
                     (Object)adaptor.create(PLUS302)
 13956   
                     ;
 13957  16 
                     adaptor.addChild(root_0, PLUS302_tree);
 13958   
 
 13959   
 
 13960   
                     }
 13961  16 
                     break;
 13962   
                 case 4 :
 13963   
                     // com\\googlecode\\sparkleg\\Sparql.g:425:42: OPEN_CURLY_BRACE ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13964   
                     {
 13965  30 
                     OPEN_CURLY_BRACE303=(Token)match(input,OPEN_CURLY_BRACE,FOLLOW_OPEN_CURLY_BRACE_in_pathMod3470);
 13966  30 
                     OPEN_CURLY_BRACE303_tree =
 13967   
                     (Object)adaptor.create(OPEN_CURLY_BRACE303)
 13968   
                     ;
 13969  30 
                     adaptor.addChild(root_0, OPEN_CURLY_BRACE303_tree);
 13970   
 
 13971   
 
 13972   
                     // com\\googlecode\\sparkleg\\Sparql.g:425:59: ( INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE ) | COMMA INTEGER CLOSE_CURLY_BRACE )
 13973  30 
                     int alt103=2;
 13974  30 
                     switch ( input.LA(1) ) {
 13975   
                     case INTEGER:
 13976   
                         {
 13977  28 
                         alt103=1;
 13978   
                         }
 13979  28 
                         break;
 13980   
                     case COMMA:
 13981   
                         {
 13982  2 
                         alt103=2;
 13983   
                         }
 13984  2 
                         break;
 13985   
                     default:
 13986  0 
                         NoViableAltException nvae =
 13987   
                             new NoViableAltException("", 103, 0, input);
 13988   
 
 13989  0 
                         throw nvae;
 13990   
 
 13991   
                     }
 13992   
 
 13993  30 
                     switch (alt103) {
 13994   
                         case 1 :
 13995   
                             // com\\googlecode\\sparkleg\\Sparql.g:425:60: INTEGER ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 13996   
                             {
 13997  28 
                             INTEGER304=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3473);
 13998  28 
                             INTEGER304_tree =
 13999   
                             (Object)adaptor.create(INTEGER304)
 14000   
                             ;
 14001  28 
                             adaptor.addChild(root_0, INTEGER304_tree);
 14002   
 
 14003   
 
 14004   
                             // com\\googlecode\\sparkleg\\Sparql.g:425:68: ( COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE ) | CLOSE_CURLY_BRACE )
 14005  28 
                             int alt102=2;
 14006  28 
                             switch ( input.LA(1) ) {
 14007   
                             case COMMA:
 14008   
                                 {
 14009  10 
                                 alt102=1;
 14010   
                                 }
 14011  10 
                                 break;
 14012   
                             case CLOSE_CURLY_BRACE:
 14013   
                                 {
 14014  18 
                                 alt102=2;
 14015   
                                 }
 14016  18 
                                 break;
 14017   
                             default:
 14018  0 
                                 NoViableAltException nvae =
 14019   
                                     new NoViableAltException("", 102, 0, input);
 14020   
 
 14021  0 
                                 throw nvae;
 14022   
 
 14023   
                             }
 14024   
 
 14025  28 
                             switch (alt102) {
 14026   
                                 case 1 :
 14027   
                                     // com\\googlecode\\sparkleg\\Sparql.g:425:69: COMMA ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 14028   
                                     {
 14029  10 
                                     COMMA305=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3476);
 14030  10 
                                     COMMA305_tree =
 14031   
                                     (Object)adaptor.create(COMMA305)
 14032   
                                     ;
 14033  10 
                                     adaptor.addChild(root_0, COMMA305_tree);
 14034   
 
 14035   
 
 14036   
                                     // com\\googlecode\\sparkleg\\Sparql.g:425:75: ( CLOSE_CURLY_BRACE | INTEGER CLOSE_CURLY_BRACE )
 14037  10 
                                     int alt101=2;
 14038  10 
                                     switch ( input.LA(1) ) {
 14039   
                                     case CLOSE_CURLY_BRACE:
 14040   
                                         {
 14041  6 
                                         alt101=1;
 14042   
                                         }
 14043  6 
                                         break;
 14044   
                                     case INTEGER:
 14045   
                                         {
 14046  4 
                                         alt101=2;
 14047   
                                         }
 14048  4 
                                         break;
 14049   
                                     default:
 14050  0 
                                         NoViableAltException nvae =
 14051   
                                             new NoViableAltException("", 101, 0, input);
 14052   
 
 14053  0 
                                         throw nvae;
 14054   
 
 14055   
                                     }
 14056   
 
 14057  10 
                                     switch (alt101) {
 14058   
                                         case 1 :
 14059   
                                             // com\\googlecode\\sparkleg\\Sparql.g:425:76: CLOSE_CURLY_BRACE
 14060   
                                             {
 14061  6 
                                             CLOSE_CURLY_BRACE306=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3479);
 14062  6 
                                             CLOSE_CURLY_BRACE306_tree =
 14063   
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE306)
 14064   
                                             ;
 14065  6 
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE306_tree);
 14066   
 
 14067   
 
 14068   
                                             }
 14069  6 
                                             break;
 14070   
                                         case 2 :
 14071   
                                             // com\\googlecode\\sparkleg\\Sparql.g:425:96: INTEGER CLOSE_CURLY_BRACE
 14072   
                                             {
 14073  4 
                                             INTEGER307=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3483);
 14074  4 
                                             INTEGER307_tree =
 14075   
                                             (Object)adaptor.create(INTEGER307)
 14076   
                                             ;
 14077  4 
                                             adaptor.addChild(root_0, INTEGER307_tree);
 14078   
 
 14079   
 
 14080  4 
                                             CLOSE_CURLY_BRACE308=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3485);
 14081  4 
                                             CLOSE_CURLY_BRACE308_tree =
 14082   
                                             (Object)adaptor.create(CLOSE_CURLY_BRACE308)
 14083   
                                             ;
 14084  4 
                                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE308_tree);
 14085   
 
 14086   
 
 14087   
                                             }
 14088   
                                             break;
 14089   
 
 14090   
                                     }
 14091   
 
 14092   
 
 14093   
                                     }
 14094  10 
                                     break;
 14095   
                                 case 2 :
 14096   
                                     // com\\googlecode\\sparkleg\\Sparql.g:425:125: CLOSE_CURLY_BRACE
 14097   
                                     {
 14098  18 
                                     CLOSE_CURLY_BRACE309=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3490);
 14099  18 
                                     CLOSE_CURLY_BRACE309_tree =
 14100   
                                     (Object)adaptor.create(CLOSE_CURLY_BRACE309)
 14101   
                                     ;
 14102  18 
                                     adaptor.addChild(root_0, CLOSE_CURLY_BRACE309_tree);
 14103   
 
 14104   
 
 14105   
                                     }
 14106   
                                     break;
 14107   
 
 14108   
                             }
 14109   
 
 14110   
 
 14111   
                             }
 14112  28 
                             break;
 14113   
                         case 2 :
 14114   
                             // com\\googlecode\\sparkleg\\Sparql.g:425:146: COMMA INTEGER CLOSE_CURLY_BRACE
 14115   
                             {
 14116  2 
                             COMMA310=(Token)match(input,COMMA,FOLLOW_COMMA_in_pathMod3495);
 14117  2 
                             COMMA310_tree =
 14118   
                             (Object)adaptor.create(COMMA310)
 14119   
                             ;
 14120  2 
                             adaptor.addChild(root_0, COMMA310_tree);
 14121   
 
 14122   
 
 14123  2 
                             INTEGER311=(Token)match(input,INTEGER,FOLLOW_INTEGER_in_pathMod3497);
 14124  2 
                             INTEGER311_tree =
 14125   
                             (Object)adaptor.create(INTEGER311)
 14126   
                             ;
 14127  2 
                             adaptor.addChild(root_0, INTEGER311_tree);
 14128   
 
 14129   
 
 14130  2 
                             CLOSE_CURLY_BRACE312=(Token)match(input,CLOSE_CURLY_BRACE,FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3499);
 14131  2 
                             CLOSE_CURLY_BRACE312_tree =
 14132   
                             (Object)adaptor.create(CLOSE_CURLY_BRACE312)
 14133   
                             ;
 14134  2 
                             adaptor.addChild(root_0, CLOSE_CURLY_BRACE312_tree);
 14135   
 
 14136   
 
 14137   
                             }
 14138   
                             break;
 14139   
 
 14140   
                     }
 14141   
 
 14142   
 
 14143   
                     }
 14144   
                     break;
 14145   
 
 14146   
             }
 14147   
 
 14148   
 
 14149   
             }
 14150   
 
 14151  66 
             retval.stop = input.LT(-1);
 14152   
 
 14153   
 
 14154  66 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14155  66 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14156   
 
 14157   
         }
 14158  0 
         catch (RecognitionException re) {
 14159  0 
             reportError(re);
 14160  0 
             recover(input,re);
 14161  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14162   
 
 14163   
         }
 14164   
 
 14165  0 
         finally {
 14166   
                 // do for sure before leaving
 14167  66 
         }
 14168  66 
         return retval;
 14169   
     }
 14170   
     // $ANTLR end "pathMod"
 14171   
 
 14172   
 
 14173  2770 
     public static class pathPrimary_return extends ParserRuleReturnScope {
 14174   
         Object tree;
 14175  2770 
         public Object getTree() { return tree; }
 14176   
     };
 14177   
 
 14178   
 
 14179   
     // $ANTLR start "pathPrimary"
 14180   
     // com\\googlecode\\sparkleg\\Sparql.g:428:1: pathPrimary : ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) );
 14181   
     public final SparqlParser.pathPrimary_return pathPrimary() throws RecognitionException {
 14182  2770 
         SparqlParser.pathPrimary_return retval = new SparqlParser.pathPrimary_return();
 14183  2770 
         retval.start = input.LT(1);
 14184   
 
 14185   
 
 14186  2770 
         Object root_0 = null;
 14187   
 
 14188  2770 
         Token A314=null;
 14189  2770 
         Token NEGATION315=null;
 14190  2770 
         Token OPEN_BRACE317=null;
 14191  2770 
         Token CLOSE_BRACE319=null;
 14192  2770 
         SparqlParser.iriRef_return iriRef313 =null;
 14193   
 
 14194  2770 
         SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet316 =null;
 14195   
 
 14196  2770 
         SparqlParser.path_return path318 =null;
 14197   
 
 14198   
 
 14199  2770 
         Object A314_tree=null;
 14200  2770 
         Object NEGATION315_tree=null;
 14201  2770 
         Object OPEN_BRACE317_tree=null;
 14202  2770 
         Object CLOSE_BRACE319_tree=null;
 14203  2770 
         RewriteRuleTokenStream stream_A=new RewriteRuleTokenStream(adaptor,"token A");
 14204  2770 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14205  2770 
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 14206  2770 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14207  2770 
         RewriteRuleSubtreeStream stream_path=new RewriteRuleSubtreeStream(adaptor,"rule path");
 14208  2770 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 14209  2770 
         RewriteRuleSubtreeStream stream_pathNegatedPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathNegatedPropertySet");
 14210   
         try {
 14211   
             // com\\googlecode\\sparkleg\\Sparql.g:429:5: ( iriRef -> ^( PATH_PRIMARY iriRef ) | A -> ^( PATH_PRIMARY A ) | NEGATION pathNegatedPropertySet -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet ) | OPEN_BRACE path CLOSE_BRACE -> ^( PATH_PRIMARY path ) )
 14212  2770 
             int alt105=4;
 14213  2770 
             switch ( input.LA(1) ) {
 14214   
             case IRI_REF:
 14215   
             case PNAME_LN:
 14216   
             case PNAME_NS:
 14217   
                 {
 14218  2680 
                 alt105=1;
 14219   
                 }
 14220  2680 
                 break;
 14221   
             case A:
 14222   
                 {
 14223  64 
                 alt105=2;
 14224   
                 }
 14225  64 
                 break;
 14226   
             case NEGATION:
 14227   
                 {
 14228  6 
                 alt105=3;
 14229   
                 }
 14230  6 
                 break;
 14231   
             case OPEN_BRACE:
 14232   
                 {
 14233  20 
                 alt105=4;
 14234   
                 }
 14235  20 
                 break;
 14236   
             default:
 14237  0 
                 NoViableAltException nvae =
 14238   
                     new NoViableAltException("", 105, 0, input);
 14239   
 
 14240  0 
                 throw nvae;
 14241   
 
 14242   
             }
 14243   
 
 14244  2770 
             switch (alt105) {
 14245   
                 case 1 :
 14246   
                     // com\\googlecode\\sparkleg\\Sparql.g:429:7: iriRef
 14247   
                     {
 14248  2680 
                     pushFollow(FOLLOW_iriRef_in_pathPrimary3518);
 14249  2680 
                     iriRef313=iriRef();
 14250   
 
 14251  2680 
                     state._fsp--;
 14252   
 
 14253  2680 
                     stream_iriRef.add(iriRef313.getTree());
 14254   
 
 14255   
                     // AST REWRITE
 14256   
                     // elements: iriRef
 14257   
                     // token labels:
 14258   
                     // rule labels: retval
 14259   
                     // token list labels:
 14260   
                     // rule list labels:
 14261   
                     // wildcard labels:
 14262  2680 
                     retval.tree = root_0;
 14263  2680 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14264   
 
 14265  2680 
                     root_0 = (Object)adaptor.nil();
 14266   
                     // 429:14: -> ^( PATH_PRIMARY iriRef )
 14267   
                     {
 14268   
                         // com\\googlecode\\sparkleg\\Sparql.g:429:17: ^( PATH_PRIMARY iriRef )
 14269   
                         {
 14270  2680 
                         Object root_1 = (Object)adaptor.nil();
 14271  2680 
                         root_1 = (Object)adaptor.becomeRoot(
 14272   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14273   
                         , root_1);
 14274   
 
 14275  2680 
                         adaptor.addChild(root_1, stream_iriRef.nextTree());
 14276   
 
 14277  2680 
                         adaptor.addChild(root_0, root_1);
 14278   
                         }
 14279   
 
 14280   
                     }
 14281   
 
 14282   
 
 14283  2680 
                     retval.tree = root_0;
 14284   
 
 14285   
                     }
 14286  2680 
                     break;
 14287   
                 case 2 :
 14288   
                     // com\\googlecode\\sparkleg\\Sparql.g:430:7: A
 14289   
                     {
 14290  64 
                     A314=(Token)match(input,A,FOLLOW_A_in_pathPrimary3534);
 14291  64 
                     stream_A.add(A314);
 14292   
 
 14293   
 
 14294   
                     // AST REWRITE
 14295   
                     // elements: A
 14296   
                     // token labels:
 14297   
                     // rule labels: retval
 14298   
                     // token list labels:
 14299   
                     // rule list labels:
 14300   
                     // wildcard labels:
 14301  64 
                     retval.tree = root_0;
 14302  64 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14303   
 
 14304  64 
                     root_0 = (Object)adaptor.nil();
 14305   
                     // 430:9: -> ^( PATH_PRIMARY A )
 14306   
                     {
 14307   
                         // com\\googlecode\\sparkleg\\Sparql.g:430:12: ^( PATH_PRIMARY A )
 14308   
                         {
 14309  64 
                         Object root_1 = (Object)adaptor.nil();
 14310  64 
                         root_1 = (Object)adaptor.becomeRoot(
 14311   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14312   
                         , root_1);
 14313   
 
 14314  64 
                         adaptor.addChild(root_1,
 14315   
                         stream_A.nextNode()
 14316   
                         );
 14317   
 
 14318  64 
                         adaptor.addChild(root_0, root_1);
 14319   
                         }
 14320   
 
 14321   
                     }
 14322   
 
 14323   
 
 14324  64 
                     retval.tree = root_0;
 14325   
 
 14326   
                     }
 14327  64 
                     break;
 14328   
                 case 3 :
 14329   
                     // com\\googlecode\\sparkleg\\Sparql.g:431:7: NEGATION pathNegatedPropertySet
 14330   
                     {
 14331  6 
                     NEGATION315=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_pathPrimary3550);
 14332  6 
                     stream_NEGATION.add(NEGATION315);
 14333   
 
 14334   
 
 14335  6 
                     pushFollow(FOLLOW_pathNegatedPropertySet_in_pathPrimary3552);
 14336  6 
                     pathNegatedPropertySet316=pathNegatedPropertySet();
 14337   
 
 14338  6 
                     state._fsp--;
 14339   
 
 14340  6 
                     stream_pathNegatedPropertySet.add(pathNegatedPropertySet316.getTree());
 14341   
 
 14342   
                     // AST REWRITE
 14343   
                     // elements: pathNegatedPropertySet, NEGATION
 14344   
                     // token labels:
 14345   
                     // rule labels: retval
 14346   
                     // token list labels:
 14347   
                     // rule list labels:
 14348   
                     // wildcard labels:
 14349  6 
                     retval.tree = root_0;
 14350  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14351   
 
 14352  6 
                     root_0 = (Object)adaptor.nil();
 14353   
                     // 431:39: -> ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14354   
                     {
 14355   
                         // com\\googlecode\\sparkleg\\Sparql.g:431:42: ^( PATH_PRIMARY NEGATION pathNegatedPropertySet )
 14356   
                         {
 14357  6 
                         Object root_1 = (Object)adaptor.nil();
 14358  6 
                         root_1 = (Object)adaptor.becomeRoot(
 14359   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14360   
                         , root_1);
 14361   
 
 14362  6 
                         adaptor.addChild(root_1,
 14363   
                         stream_NEGATION.nextNode()
 14364   
                         );
 14365   
 
 14366  6 
                         adaptor.addChild(root_1, stream_pathNegatedPropertySet.nextTree());
 14367   
 
 14368  6 
                         adaptor.addChild(root_0, root_1);
 14369   
                         }
 14370   
 
 14371   
                     }
 14372   
 
 14373   
 
 14374  6 
                     retval.tree = root_0;
 14375   
 
 14376   
                     }
 14377  6 
                     break;
 14378   
                 case 4 :
 14379   
                     // com\\googlecode\\sparkleg\\Sparql.g:432:7: OPEN_BRACE path CLOSE_BRACE
 14380   
                     {
 14381  20 
                     OPEN_BRACE317=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathPrimary3570);
 14382  20 
                     stream_OPEN_BRACE.add(OPEN_BRACE317);
 14383   
 
 14384   
 
 14385  20 
                     pushFollow(FOLLOW_path_in_pathPrimary3572);
 14386  20 
                     path318=path();
 14387   
 
 14388  20 
                     state._fsp--;
 14389   
 
 14390  20 
                     stream_path.add(path318.getTree());
 14391   
 
 14392  20 
                     CLOSE_BRACE319=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathPrimary3574);
 14393  20 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE319);
 14394   
 
 14395   
 
 14396   
                     // AST REWRITE
 14397   
                     // elements: path
 14398   
                     // token labels:
 14399   
                     // rule labels: retval
 14400   
                     // token list labels:
 14401   
                     // rule list labels:
 14402   
                     // wildcard labels:
 14403  20 
                     retval.tree = root_0;
 14404  20 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14405   
 
 14406  20 
                     root_0 = (Object)adaptor.nil();
 14407   
                     // 432:35: -> ^( PATH_PRIMARY path )
 14408   
                     {
 14409   
                         // com\\googlecode\\sparkleg\\Sparql.g:432:38: ^( PATH_PRIMARY path )
 14410   
                         {
 14411  20 
                         Object root_1 = (Object)adaptor.nil();
 14412  20 
                         root_1 = (Object)adaptor.becomeRoot(
 14413   
                         (Object)adaptor.create(PATH_PRIMARY, "PATH_PRIMARY")
 14414   
                         , root_1);
 14415   
 
 14416  20 
                         adaptor.addChild(root_1, stream_path.nextTree());
 14417   
 
 14418  20 
                         adaptor.addChild(root_0, root_1);
 14419   
                         }
 14420   
 
 14421   
                     }
 14422   
 
 14423   
 
 14424  20 
                     retval.tree = root_0;
 14425   
 
 14426   
                     }
 14427   
                     break;
 14428   
 
 14429   
             }
 14430  2770 
             retval.stop = input.LT(-1);
 14431   
 
 14432   
 
 14433  2770 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14434  2770 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14435   
 
 14436   
         }
 14437  0 
         catch (RecognitionException re) {
 14438  0 
             reportError(re);
 14439  0 
             recover(input,re);
 14440  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14441   
 
 14442   
         }
 14443   
 
 14444  0 
         finally {
 14445   
                 // do for sure before leaving
 14446  2770 
         }
 14447  2770 
         return retval;
 14448   
     }
 14449   
     // $ANTLR end "pathPrimary"
 14450   
 
 14451   
 
 14452  6 
     public static class pathNegatedPropertySet_return extends ParserRuleReturnScope {
 14453   
         Object tree;
 14454  6 
         public Object getTree() { return tree; }
 14455   
     };
 14456   
 
 14457   
 
 14458   
     // $ANTLR start "pathNegatedPropertySet"
 14459   
     // com\\googlecode\\sparkleg\\Sparql.g:435:1: pathNegatedPropertySet : ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) );
 14460   
     public final SparqlParser.pathNegatedPropertySet_return pathNegatedPropertySet() throws RecognitionException {
 14461  6 
         SparqlParser.pathNegatedPropertySet_return retval = new SparqlParser.pathNegatedPropertySet_return();
 14462  6 
         retval.start = input.LT(1);
 14463   
 
 14464   
 
 14465  6 
         Object root_0 = null;
 14466   
 
 14467  6 
         Token OPEN_BRACE321=null;
 14468  6 
         Token PIPE323=null;
 14469  6 
         Token CLOSE_BRACE325=null;
 14470  6 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet320 =null;
 14471   
 
 14472  6 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet322 =null;
 14473   
 
 14474  6 
         SparqlParser.pathOneInPropertySet_return pathOneInPropertySet324 =null;
 14475   
 
 14476   
 
 14477  6 
         Object OPEN_BRACE321_tree=null;
 14478  6 
         Object PIPE323_tree=null;
 14479  6 
         Object CLOSE_BRACE325_tree=null;
 14480  6 
         RewriteRuleTokenStream stream_PIPE=new RewriteRuleTokenStream(adaptor,"token PIPE");
 14481  6 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14482  6 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14483  6 
         RewriteRuleSubtreeStream stream_pathOneInPropertySet=new RewriteRuleSubtreeStream(adaptor,"rule pathOneInPropertySet");
 14484   
         try {
 14485   
             // com\\googlecode\\sparkleg\\Sparql.g:436:5: ( pathOneInPropertySet -> ^( PATH_NEGATED pathOneInPropertySet ) | OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE -> ^( PATH_NEGATED ( pathOneInPropertySet )+ ) )
 14486  6 
             int alt108=2;
 14487  6 
             switch ( input.LA(1) ) {
 14488   
             case A:
 14489   
             case INVERSE:
 14490   
             case IRI_REF:
 14491   
             case PNAME_LN:
 14492   
             case PNAME_NS:
 14493   
                 {
 14494  0 
                 alt108=1;
 14495   
                 }
 14496  0 
                 break;
 14497   
             case OPEN_BRACE:
 14498   
                 {
 14499  6 
                 alt108=2;
 14500   
                 }
 14501  6 
                 break;
 14502   
             default:
 14503  0 
                 NoViableAltException nvae =
 14504   
                     new NoViableAltException("", 108, 0, input);
 14505   
 
 14506  0 
                 throw nvae;
 14507   
 
 14508   
             }
 14509   
 
 14510  6 
             switch (alt108) {
 14511   
                 case 1 :
 14512   
                     // com\\googlecode\\sparkleg\\Sparql.g:436:7: pathOneInPropertySet
 14513   
                     {
 14514  0 
                     pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3599);
 14515  0 
                     pathOneInPropertySet320=pathOneInPropertySet();
 14516   
 
 14517  0 
                     state._fsp--;
 14518   
 
 14519  0 
                     stream_pathOneInPropertySet.add(pathOneInPropertySet320.getTree());
 14520   
 
 14521   
                     // AST REWRITE
 14522   
                     // elements: pathOneInPropertySet
 14523   
                     // token labels:
 14524   
                     // rule labels: retval
 14525   
                     // token list labels:
 14526   
                     // rule list labels:
 14527   
                     // wildcard labels:
 14528  0 
                     retval.tree = root_0;
 14529  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14530   
 
 14531  0 
                     root_0 = (Object)adaptor.nil();
 14532   
                     // 436:28: -> ^( PATH_NEGATED pathOneInPropertySet )
 14533   
                     {
 14534   
                         // com\\googlecode\\sparkleg\\Sparql.g:436:31: ^( PATH_NEGATED pathOneInPropertySet )
 14535   
                         {
 14536  0 
                         Object root_1 = (Object)adaptor.nil();
 14537  0 
                         root_1 = (Object)adaptor.becomeRoot(
 14538   
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14539   
                         , root_1);
 14540   
 
 14541  0 
                         adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14542   
 
 14543  0 
                         adaptor.addChild(root_0, root_1);
 14544   
                         }
 14545   
 
 14546   
                     }
 14547   
 
 14548   
 
 14549  0 
                     retval.tree = root_0;
 14550   
 
 14551   
                     }
 14552  0 
                     break;
 14553   
                 case 2 :
 14554   
                     // com\\googlecode\\sparkleg\\Sparql.g:437:7: OPEN_BRACE ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )? CLOSE_BRACE
 14555   
                     {
 14556  6 
                     OPEN_BRACE321=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3615);
 14557  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE321);
 14558   
 
 14559   
 
 14560   
                     // com\\googlecode\\sparkleg\\Sparql.g:437:18: ( pathOneInPropertySet ( PIPE pathOneInPropertySet )* )?
 14561  6 
                     int alt107=2;
 14562  6 
                     switch ( input.LA(1) ) {
 14563   
                         case A:
 14564   
                         case INVERSE:
 14565   
                         case IRI_REF:
 14566   
                         case PNAME_LN:
 14567   
                         case PNAME_NS:
 14568   
                             {
 14569  6 
                             alt107=1;
 14570   
                             }
 14571   
                             break;
 14572   
                     }
 14573   
 
 14574  6 
                     switch (alt107) {
 14575   
                         case 1 :
 14576   
                             // com\\googlecode\\sparkleg\\Sparql.g:437:19: pathOneInPropertySet ( PIPE pathOneInPropertySet )*
 14577   
                             {
 14578  6 
                             pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3618);
 14579  6 
                             pathOneInPropertySet322=pathOneInPropertySet();
 14580   
 
 14581  6 
                             state._fsp--;
 14582   
 
 14583  6 
                             stream_pathOneInPropertySet.add(pathOneInPropertySet322.getTree());
 14584   
 
 14585   
                             // com\\googlecode\\sparkleg\\Sparql.g:437:40: ( PIPE pathOneInPropertySet )*
 14586   
                             loop106:
 14587   
                             do {
 14588  12 
                                 int alt106=2;
 14589  12 
                                 switch ( input.LA(1) ) {
 14590   
                                 case PIPE:
 14591   
                                     {
 14592  6 
                                     alt106=1;
 14593   
                                     }
 14594   
                                     break;
 14595   
 
 14596   
                                 }
 14597   
 
 14598  12 
                                 switch (alt106) {
 14599   
                                     case 1 :
 14600   
                                         // com\\googlecode\\sparkleg\\Sparql.g:437:41: PIPE pathOneInPropertySet
 14601   
                                         {
 14602  6 
                                         PIPE323=(Token)match(input,PIPE,FOLLOW_PIPE_in_pathNegatedPropertySet3621);
 14603  6 
                                         stream_PIPE.add(PIPE323);
 14604   
 
 14605   
 
 14606  6 
                                         pushFollow(FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3623);
 14607  6 
                                         pathOneInPropertySet324=pathOneInPropertySet();
 14608   
 
 14609  6 
                                         state._fsp--;
 14610   
 
 14611  6 
                                         stream_pathOneInPropertySet.add(pathOneInPropertySet324.getTree());
 14612   
 
 14613   
                                         }
 14614  6 
                                         break;
 14615   
 
 14616   
                                     default :
 14617  6 
                                         break loop106;
 14618   
                                 }
 14619  6 
                             } while (true);
 14620   
 
 14621   
 
 14622   
                             }
 14623   
                             break;
 14624   
 
 14625   
                     }
 14626   
 
 14627   
 
 14628  6 
                     CLOSE_BRACE325=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3629);
 14629  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE325);
 14630   
 
 14631   
 
 14632   
                     // AST REWRITE
 14633   
                     // elements: pathOneInPropertySet
 14634   
                     // token labels:
 14635   
                     // rule labels: retval
 14636   
                     // token list labels:
 14637   
                     // rule list labels:
 14638   
                     // wildcard labels:
 14639  6 
                     retval.tree = root_0;
 14640  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14641   
 
 14642  6 
                     root_0 = (Object)adaptor.nil();
 14643   
                     // 437:83: -> ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14644   
                     {
 14645   
                         // com\\googlecode\\sparkleg\\Sparql.g:437:86: ^( PATH_NEGATED ( pathOneInPropertySet )+ )
 14646   
                         {
 14647  6 
                         Object root_1 = (Object)adaptor.nil();
 14648  6 
                         root_1 = (Object)adaptor.becomeRoot(
 14649   
                         (Object)adaptor.create(PATH_NEGATED, "PATH_NEGATED")
 14650   
                         , root_1);
 14651   
 
 14652  6 
                         if ( !(stream_pathOneInPropertySet.hasNext()) ) {
 14653  0 
                             throw new RewriteEarlyExitException();
 14654   
                         }
 14655  18 
                         while ( stream_pathOneInPropertySet.hasNext() ) {
 14656  12 
                             adaptor.addChild(root_1, stream_pathOneInPropertySet.nextTree());
 14657   
 
 14658   
                         }
 14659  6 
                         stream_pathOneInPropertySet.reset();
 14660   
 
 14661  6 
                         adaptor.addChild(root_0, root_1);
 14662   
                         }
 14663   
 
 14664   
                     }
 14665   
 
 14666   
 
 14667  6 
                     retval.tree = root_0;
 14668   
 
 14669   
                     }
 14670   
                     break;
 14671   
 
 14672   
             }
 14673  6 
             retval.stop = input.LT(-1);
 14674   
 
 14675   
 
 14676  6 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14677  6 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14678   
 
 14679   
         }
 14680  0 
         catch (RecognitionException re) {
 14681  0 
             reportError(re);
 14682  0 
             recover(input,re);
 14683  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14684   
 
 14685   
         }
 14686   
 
 14687  0 
         finally {
 14688   
                 // do for sure before leaving
 14689  6 
         }
 14690  6 
         return retval;
 14691   
     }
 14692   
     // $ANTLR end "pathNegatedPropertySet"
 14693   
 
 14694   
 
 14695  12 
     public static class pathOneInPropertySet_return extends ParserRuleReturnScope {
 14696   
         Object tree;
 14697  12 
         public Object getTree() { return tree; }
 14698   
     };
 14699   
 
 14700   
 
 14701   
     // $ANTLR start "pathOneInPropertySet"
 14702   
     // com\\googlecode\\sparkleg\\Sparql.g:440:1: pathOneInPropertySet : ( INVERSE )? ( iriRef | A ) ;
 14703   
     public final SparqlParser.pathOneInPropertySet_return pathOneInPropertySet() throws RecognitionException {
 14704  12 
         SparqlParser.pathOneInPropertySet_return retval = new SparqlParser.pathOneInPropertySet_return();
 14705  12 
         retval.start = input.LT(1);
 14706   
 
 14707   
 
 14708  12 
         Object root_0 = null;
 14709   
 
 14710  12 
         Token INVERSE326=null;
 14711  12 
         Token A328=null;
 14712  12 
         SparqlParser.iriRef_return iriRef327 =null;
 14713   
 
 14714   
 
 14715  12 
         Object INVERSE326_tree=null;
 14716  12 
         Object A328_tree=null;
 14717   
 
 14718   
         try {
 14719   
             // com\\googlecode\\sparkleg\\Sparql.g:441:5: ( ( INVERSE )? ( iriRef | A ) )
 14720   
             // com\\googlecode\\sparkleg\\Sparql.g:441:7: ( INVERSE )? ( iriRef | A )
 14721   
             {
 14722  12 
             root_0 = (Object)adaptor.nil();
 14723   
 
 14724   
 
 14725   
             // com\\googlecode\\sparkleg\\Sparql.g:441:7: ( INVERSE )?
 14726  12 
             int alt109=2;
 14727  12 
             switch ( input.LA(1) ) {
 14728   
                 case INVERSE:
 14729   
                     {
 14730  4 
                     alt109=1;
 14731   
                     }
 14732   
                     break;
 14733   
             }
 14734   
 
 14735  12 
             switch (alt109) {
 14736   
                 case 1 :
 14737   
                     // com\\googlecode\\sparkleg\\Sparql.g:441:7: INVERSE
 14738   
                     {
 14739  4 
                     INVERSE326=(Token)match(input,INVERSE,FOLLOW_INVERSE_in_pathOneInPropertySet3658);
 14740  4 
                     INVERSE326_tree =
 14741   
                     (Object)adaptor.create(INVERSE326)
 14742   
                     ;
 14743  4 
                     adaptor.addChild(root_0, INVERSE326_tree);
 14744   
 
 14745   
 
 14746   
                     }
 14747   
                     break;
 14748   
 
 14749   
             }
 14750   
 
 14751   
 
 14752   
             // com\\googlecode\\sparkleg\\Sparql.g:441:16: ( iriRef | A )
 14753  12 
             int alt110=2;
 14754  12 
             switch ( input.LA(1) ) {
 14755   
             case IRI_REF:
 14756   
             case PNAME_LN:
 14757   
             case PNAME_NS:
 14758   
                 {
 14759  12 
                 alt110=1;
 14760   
                 }
 14761  12 
                 break;
 14762   
             case A:
 14763   
                 {
 14764  0 
                 alt110=2;
 14765   
                 }
 14766  0 
                 break;
 14767   
             default:
 14768  0 
                 NoViableAltException nvae =
 14769   
                     new NoViableAltException("", 110, 0, input);
 14770   
 
 14771  0 
                 throw nvae;
 14772   
 
 14773   
             }
 14774   
 
 14775  12 
             switch (alt110) {
 14776   
                 case 1 :
 14777   
                     // com\\googlecode\\sparkleg\\Sparql.g:441:17: iriRef
 14778   
                     {
 14779  12 
                     pushFollow(FOLLOW_iriRef_in_pathOneInPropertySet3662);
 14780  12 
                     iriRef327=iriRef();
 14781   
 
 14782  12 
                     state._fsp--;
 14783   
 
 14784  12 
                     adaptor.addChild(root_0, iriRef327.getTree());
 14785   
 
 14786   
                     }
 14787  12 
                     break;
 14788   
                 case 2 :
 14789   
                     // com\\googlecode\\sparkleg\\Sparql.g:441:26: A
 14790   
                     {
 14791  0 
                     A328=(Token)match(input,A,FOLLOW_A_in_pathOneInPropertySet3666);
 14792  0 
                     A328_tree =
 14793   
                     (Object)adaptor.create(A328)
 14794   
                     ;
 14795  0 
                     adaptor.addChild(root_0, A328_tree);
 14796   
 
 14797   
 
 14798   
                     }
 14799   
                     break;
 14800   
 
 14801   
             }
 14802   
 
 14803   
 
 14804   
             }
 14805   
 
 14806  12 
             retval.stop = input.LT(-1);
 14807   
 
 14808   
 
 14809  12 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 14810  12 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 14811   
 
 14812   
         }
 14813  0 
         catch (RecognitionException re) {
 14814  0 
             reportError(re);
 14815  0 
             recover(input,re);
 14816  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 14817   
 
 14818   
         }
 14819   
 
 14820  0 
         finally {
 14821   
                 // do for sure before leaving
 14822  12 
         }
 14823  12 
         return retval;
 14824   
     }
 14825   
     // $ANTLR end "pathOneInPropertySet"
 14826   
 
 14827   
 
 14828  66 
     public static class triplesNode_return extends ParserRuleReturnScope {
 14829   
         Object tree;
 14830  66 
         public Object getTree() { return tree; }
 14831   
     };
 14832   
 
 14833   
 
 14834   
     // $ANTLR start "triplesNode"
 14835   
     // com\\googlecode\\sparkleg\\Sparql.g:444:1: triplesNode : ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) );
 14836   
     public final SparqlParser.triplesNode_return triplesNode() throws RecognitionException {
 14837  66 
         SparqlParser.triplesNode_return retval = new SparqlParser.triplesNode_return();
 14838  66 
         retval.start = input.LT(1);
 14839   
 
 14840   
 
 14841  66 
         Object root_0 = null;
 14842   
 
 14843  66 
         Token OPEN_BRACE329=null;
 14844  66 
         Token CLOSE_BRACE331=null;
 14845  66 
         Token OPEN_SQUARE_BRACKET332=null;
 14846  66 
         Token CLOSE_SQUARE_BRACKET334=null;
 14847  66 
         SparqlParser.graphNode_return graphNode330 =null;
 14848   
 
 14849  66 
         SparqlParser.propertyListNotEmpty_return propertyListNotEmpty333 =null;
 14850   
 
 14851   
 
 14852  66 
         Object OPEN_BRACE329_tree=null;
 14853  66 
         Object CLOSE_BRACE331_tree=null;
 14854  66 
         Object OPEN_SQUARE_BRACKET332_tree=null;
 14855  66 
         Object CLOSE_SQUARE_BRACKET334_tree=null;
 14856  66 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 14857  66 
         RewriteRuleTokenStream stream_OPEN_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token OPEN_SQUARE_BRACKET");
 14858  66 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 14859  66 
         RewriteRuleTokenStream stream_CLOSE_SQUARE_BRACKET=new RewriteRuleTokenStream(adaptor,"token CLOSE_SQUARE_BRACKET");
 14860  66 
         RewriteRuleSubtreeStream stream_graphNode=new RewriteRuleSubtreeStream(adaptor,"rule graphNode");
 14861  66 
         RewriteRuleSubtreeStream stream_propertyListNotEmpty=new RewriteRuleSubtreeStream(adaptor,"rule propertyListNotEmpty");
 14862   
         try {
 14863   
             // com\\googlecode\\sparkleg\\Sparql.g:445:5: ( OPEN_BRACE ( graphNode )+ CLOSE_BRACE -> ^( COLLECTION ( graphNode )+ ) | OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET -> ^( TRIPLES_NODE propertyListNotEmpty ) )
 14864  66 
             int alt112=2;
 14865  66 
             switch ( input.LA(1) ) {
 14866   
             case OPEN_BRACE:
 14867   
                 {
 14868  28 
                 alt112=1;
 14869   
                 }
 14870  28 
                 break;
 14871   
             case OPEN_SQUARE_BRACKET:
 14872   
                 {
 14873  38 
                 alt112=2;
 14874   
                 }
 14875  38 
                 break;
 14876   
             default:
 14877  0 
                 NoViableAltException nvae =
 14878   
                     new NoViableAltException("", 112, 0, input);
 14879   
 
 14880  0 
                 throw nvae;
 14881   
 
 14882   
             }
 14883   
 
 14884  66 
             switch (alt112) {
 14885   
                 case 1 :
 14886   
                     // com\\googlecode\\sparkleg\\Sparql.g:445:7: OPEN_BRACE ( graphNode )+ CLOSE_BRACE
 14887   
                     {
 14888  28 
                     OPEN_BRACE329=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_triplesNode3685);
 14889  28 
                     stream_OPEN_BRACE.add(OPEN_BRACE329);
 14890   
 
 14891   
 
 14892   
                     // com\\googlecode\\sparkleg\\Sparql.g:445:18: ( graphNode )+
 14893  28 
                     int cnt111=0;
 14894   
                     loop111:
 14895   
                     do {
 14896  66 
                         int alt111=2;
 14897  66 
                         switch ( input.LA(1) ) {
 14898   
                         case BLANK_NODE_LABEL:
 14899   
                         case DECIMAL:
 14900   
                         case DECIMAL_NEGATIVE:
 14901   
                         case DECIMAL_POSITIVE:
 14902   
                         case DOUBLE:
 14903   
                         case DOUBLE_NEGATIVE:
 14904   
                         case DOUBLE_POSITIVE:
 14905   
                         case FALSE:
 14906   
                         case INTEGER:
 14907   
                         case INTEGER_NEGATIVE:
 14908   
                         case INTEGER_POSITIVE:
 14909   
                         case IRI_REF:
 14910   
                         case OPEN_BRACE:
 14911   
                         case OPEN_SQUARE_BRACKET:
 14912   
                         case PNAME_LN:
 14913   
                         case PNAME_NS:
 14914   
                         case STRING_LITERAL1:
 14915   
                         case STRING_LITERAL2:
 14916   
                         case STRING_LITERAL_LONG1:
 14917   
                         case STRING_LITERAL_LONG2:
 14918   
                         case TRUE:
 14919   
                         case VAR1:
 14920   
                         case VAR2:
 14921   
                             {
 14922  38 
                             alt111=1;
 14923   
                             }
 14924   
                             break;
 14925   
 
 14926   
                         }
 14927   
 
 14928  66 
                         switch (alt111) {
 14929   
                             case 1 :
 14930   
                                 // com\\googlecode\\sparkleg\\Sparql.g:445:18: graphNode
 14931   
                                 {
 14932  38 
                                 pushFollow(FOLLOW_graphNode_in_triplesNode3687);
 14933  38 
                                 graphNode330=graphNode();
 14934   
 
 14935  38 
                                 state._fsp--;
 14936   
 
 14937  38 
                                 stream_graphNode.add(graphNode330.getTree());
 14938   
 
 14939   
                                 }
 14940  38 
                                 break;
 14941   
 
 14942   
                             default :
 14943  28 
                                 if ( cnt111 >= 1 ) break loop111;
 14944  0 
                                 EarlyExitException eee =
 14945   
                                     new EarlyExitException(111, input);
 14946  0 
                                 throw eee;
 14947   
                         }
 14948  38 
                         cnt111++;
 14949  38 
                     } while (true);
 14950   
 
 14951   
 
 14952  28 
                     CLOSE_BRACE331=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_triplesNode3690);
 14953  28 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE331);
 14954   
 
 14955   
 
 14956   
                     // AST REWRITE
 14957   
                     // elements: graphNode
 14958   
                     // token labels:
 14959   
                     // rule labels: retval
 14960   
                     // token list labels:
 14961   
                     // rule list labels:
 14962   
                     // wildcard labels:
 14963  28 
                     retval.tree = root_0;
 14964  28 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 14965   
 
 14966  28 
                     root_0 = (Object)adaptor.nil();
 14967   
                     // 445:41: -> ^( COLLECTION ( graphNode )+ )
 14968   
                     {
 14969   
                         // com\\googlecode\\sparkleg\\Sparql.g:445:44: ^( COLLECTION ( graphNode )+ )
 14970   
                         {
 14971  28 
                         Object root_1 = (Object)adaptor.nil();
 14972  28 
                         root_1 = (Object)adaptor.becomeRoot(
 14973   
                         (Object)adaptor.create(COLLECTION, "COLLECTION")
 14974   
                         , root_1);
 14975   
 
 14976  28 
                         if ( !(stream_graphNode.hasNext()) ) {
 14977  0 
                             throw new RewriteEarlyExitException();
 14978   
                         }
 14979  66 
                         while ( stream_graphNode.hasNext() ) {
 14980  38 
                             adaptor.addChild(root_1, stream_graphNode.nextTree());
 14981   
 
 14982   
                         }
 14983  28 
                         stream_graphNode.reset();
 14984   
 
 14985  28 
                         adaptor.addChild(root_0, root_1);
 14986   
                         }
 14987   
 
 14988   
                     }
 14989   
 
 14990   
 
 14991  28 
                     retval.tree = root_0;
 14992   
 
 14993   
                     }
 14994  28 
                     break;
 14995   
                 case 2 :
 14996   
                     // com\\googlecode\\sparkleg\\Sparql.g:446:7: OPEN_SQUARE_BRACKET propertyListNotEmpty CLOSE_SQUARE_BRACKET
 14997   
                     {
 14998  38 
                     OPEN_SQUARE_BRACKET332=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3707);
 14999  38 
                     stream_OPEN_SQUARE_BRACKET.add(OPEN_SQUARE_BRACKET332);
 15000   
 
 15001   
 
 15002  38 
                     pushFollow(FOLLOW_propertyListNotEmpty_in_triplesNode3709);
 15003  38 
                     propertyListNotEmpty333=propertyListNotEmpty();
 15004   
 
 15005  38 
                     state._fsp--;
 15006   
 
 15007  38 
                     stream_propertyListNotEmpty.add(propertyListNotEmpty333.getTree());
 15008   
 
 15009  38 
                     CLOSE_SQUARE_BRACKET334=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3711);
 15010  38 
                     stream_CLOSE_SQUARE_BRACKET.add(CLOSE_SQUARE_BRACKET334);
 15011   
 
 15012   
 
 15013   
                     // AST REWRITE
 15014   
                     // elements: propertyListNotEmpty
 15015   
                     // token labels:
 15016   
                     // rule labels: retval
 15017   
                     // token list labels:
 15018   
                     // rule list labels:
 15019   
                     // wildcard labels:
 15020  38 
                     retval.tree = root_0;
 15021  38 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15022   
 
 15023  38 
                     root_0 = (Object)adaptor.nil();
 15024   
                     // 446:69: -> ^( TRIPLES_NODE propertyListNotEmpty )
 15025   
                     {
 15026   
                         // com\\googlecode\\sparkleg\\Sparql.g:446:72: ^( TRIPLES_NODE propertyListNotEmpty )
 15027   
                         {
 15028  38 
                         Object root_1 = (Object)adaptor.nil();
 15029  38 
                         root_1 = (Object)adaptor.becomeRoot(
 15030   
                         (Object)adaptor.create(TRIPLES_NODE, "TRIPLES_NODE")
 15031   
                         , root_1);
 15032   
 
 15033  38 
                         adaptor.addChild(root_1, stream_propertyListNotEmpty.nextTree());
 15034   
 
 15035  38 
                         adaptor.addChild(root_0, root_1);
 15036   
                         }
 15037   
 
 15038   
                     }
 15039   
 
 15040   
 
 15041  38 
                     retval.tree = root_0;
 15042   
 
 15043   
                     }
 15044   
                     break;
 15045   
 
 15046   
             }
 15047  66 
             retval.stop = input.LT(-1);
 15048   
 
 15049   
 
 15050  66 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15051  66 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15052   
 
 15053   
         }
 15054  0 
         catch (RecognitionException re) {
 15055  0 
             reportError(re);
 15056  0 
             recover(input,re);
 15057  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15058   
 
 15059   
         }
 15060   
 
 15061  0 
         finally {
 15062   
                 // do for sure before leaving
 15063  66 
         }
 15064  66 
         return retval;
 15065   
     }
 15066   
     // $ANTLR end "triplesNode"
 15067   
 
 15068   
 
 15069  3396 
     public static class graphNode_return extends ParserRuleReturnScope {
 15070   
         Object tree;
 15071  3396 
         public Object getTree() { return tree; }
 15072   
     };
 15073   
 
 15074   
 
 15075   
     // $ANTLR start "graphNode"
 15076   
     // com\\googlecode\\sparkleg\\Sparql.g:449:1: graphNode : ( varOrTerm | triplesNode );
 15077   
     public final SparqlParser.graphNode_return graphNode() throws RecognitionException {
 15078  3396 
         SparqlParser.graphNode_return retval = new SparqlParser.graphNode_return();
 15079  3396 
         retval.start = input.LT(1);
 15080   
 
 15081   
 
 15082  3396 
         Object root_0 = null;
 15083   
 
 15084  3396 
         SparqlParser.varOrTerm_return varOrTerm335 =null;
 15085   
 
 15086  3396 
         SparqlParser.triplesNode_return triplesNode336 =null;
 15087   
 
 15088   
 
 15089   
 
 15090   
         try {
 15091   
             // com\\googlecode\\sparkleg\\Sparql.g:450:5: ( varOrTerm | triplesNode )
 15092  3396 
             int alt113=2;
 15093  3396 
             switch ( input.LA(1) ) {
 15094   
             case BLANK_NODE_LABEL:
 15095   
             case DECIMAL:
 15096   
             case DECIMAL_NEGATIVE:
 15097   
             case DECIMAL_POSITIVE:
 15098   
             case DOUBLE:
 15099   
             case DOUBLE_NEGATIVE:
 15100   
             case DOUBLE_POSITIVE:
 15101   
             case FALSE:
 15102   
             case INTEGER:
 15103   
             case INTEGER_NEGATIVE:
 15104   
             case INTEGER_POSITIVE:
 15105   
             case IRI_REF:
 15106   
             case PNAME_LN:
 15107   
             case PNAME_NS:
 15108   
             case STRING_LITERAL1:
 15109   
             case STRING_LITERAL2:
 15110   
             case STRING_LITERAL_LONG1:
 15111   
             case STRING_LITERAL_LONG2:
 15112   
             case TRUE:
 15113   
             case VAR1:
 15114   
             case VAR2:
 15115   
                 {
 15116  3336 
                 alt113=1;
 15117   
                 }
 15118  3336 
                 break;
 15119   
             case OPEN_SQUARE_BRACKET:
 15120   
                 {
 15121  44 
                 switch ( input.LA(2) ) {
 15122   
                 case CLOSE_SQUARE_BRACKET:
 15123   
                     {
 15124  22 
                     alt113=1;
 15125   
                     }
 15126  22 
                     break;
 15127   
                 case A:
 15128   
                 case INVERSE:
 15129   
                 case IRI_REF:
 15130   
                 case NEGATION:
 15131   
                 case OPEN_BRACE:
 15132   
                 case PNAME_LN:
 15133   
                 case PNAME_NS:
 15134   
                 case VAR1:
 15135   
                 case VAR2:
 15136   
                     {
 15137  22 
                     alt113=2;
 15138   
                     }
 15139  22 
                     break;
 15140   
                 default:
 15141  0 
                     NoViableAltException nvae =
 15142   
                         new NoViableAltException("", 113, 2, input);
 15143   
 
 15144  0 
                     throw nvae;
 15145   
 
 15146   
                 }
 15147   
 
 15148   
                 }
 15149  44 
                 break;
 15150   
             case OPEN_BRACE:
 15151   
                 {
 15152  16 
                 switch ( input.LA(2) ) {
 15153   
                 case CLOSE_BRACE:
 15154   
                     {
 15155  4 
                     alt113=1;
 15156   
                     }
 15157  4 
                     break;
 15158   
                 case BLANK_NODE_LABEL:
 15159   
                 case DECIMAL:
 15160   
                 case DECIMAL_NEGATIVE:
 15161   
                 case DECIMAL_POSITIVE:
 15162   
                 case DOUBLE:
 15163   
                 case DOUBLE_NEGATIVE:
 15164   
                 case DOUBLE_POSITIVE:
 15165   
                 case FALSE:
 15166   
                 case INTEGER:
 15167   
                 case INTEGER_NEGATIVE:
 15168   
                 case INTEGER_POSITIVE:
 15169   
                 case IRI_REF:
 15170   
                 case OPEN_BRACE:
 15171   
                 case OPEN_SQUARE_BRACKET:
 15172   
                 case PNAME_LN:
 15173   
                 case PNAME_NS:
 15174   
                 case STRING_LITERAL1:
 15175   
                 case STRING_LITERAL2:
 15176   
                 case STRING_LITERAL_LONG1:
 15177   
                 case STRING_LITERAL_LONG2:
 15178   
                 case TRUE:
 15179   
                 case VAR1:
 15180   
                 case VAR2:
 15181   
                     {
 15182  12 
                     alt113=2;
 15183   
                     }
 15184  12 
                     break;
 15185   
                 default:
 15186  0 
                     NoViableAltException nvae =
 15187   
                         new NoViableAltException("", 113, 3, input);
 15188   
 
 15189  0 
                     throw nvae;
 15190   
 
 15191   
                 }
 15192   
 
 15193   
                 }
 15194  16 
                 break;
 15195   
             default:
 15196  0 
                 NoViableAltException nvae =
 15197   
                     new NoViableAltException("", 113, 0, input);
 15198   
 
 15199  0 
                 throw nvae;
 15200   
 
 15201   
             }
 15202   
 
 15203  3396 
             switch (alt113) {
 15204   
                 case 1 :
 15205   
                     // com\\googlecode\\sparkleg\\Sparql.g:450:7: varOrTerm
 15206   
                     {
 15207  3362 
                     root_0 = (Object)adaptor.nil();
 15208   
 
 15209   
 
 15210  3362 
                     pushFollow(FOLLOW_varOrTerm_in_graphNode3736);
 15211  3362 
                     varOrTerm335=varOrTerm();
 15212   
 
 15213  3362 
                     state._fsp--;
 15214   
 
 15215  3362 
                     adaptor.addChild(root_0, varOrTerm335.getTree());
 15216   
 
 15217   
                     }
 15218  3362 
                     break;
 15219   
                 case 2 :
 15220   
                     // com\\googlecode\\sparkleg\\Sparql.g:450:19: triplesNode
 15221   
                     {
 15222  34 
                     root_0 = (Object)adaptor.nil();
 15223   
 
 15224   
 
 15225  34 
                     pushFollow(FOLLOW_triplesNode_in_graphNode3740);
 15226  34 
                     triplesNode336=triplesNode();
 15227   
 
 15228  34 
                     state._fsp--;
 15229   
 
 15230  34 
                     adaptor.addChild(root_0, triplesNode336.getTree());
 15231   
 
 15232   
                     }
 15233   
                     break;
 15234   
 
 15235   
             }
 15236  3396 
             retval.stop = input.LT(-1);
 15237   
 
 15238   
 
 15239  3396 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15240  3396 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15241   
 
 15242   
         }
 15243  0 
         catch (RecognitionException re) {
 15244  0 
             reportError(re);
 15245  0 
             recover(input,re);
 15246  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15247   
 
 15248   
         }
 15249   
 
 15250  0 
         finally {
 15251   
                 // do for sure before leaving
 15252  3396 
         }
 15253  3396 
         return retval;
 15254   
     }
 15255   
     // $ANTLR end "graphNode"
 15256   
 
 15257   
 
 15258  6438 
     public static class varOrTerm_return extends ParserRuleReturnScope {
 15259   
         Object tree;
 15260  6438 
         public Object getTree() { return tree; }
 15261   
     };
 15262   
 
 15263   
 
 15264   
     // $ANTLR start "varOrTerm"
 15265   
     // com\\googlecode\\sparkleg\\Sparql.g:453:1: varOrTerm : ( var | graphTerm );
 15266   
     public final SparqlParser.varOrTerm_return varOrTerm() throws RecognitionException {
 15267  6438 
         SparqlParser.varOrTerm_return retval = new SparqlParser.varOrTerm_return();
 15268  6438 
         retval.start = input.LT(1);
 15269   
 
 15270   
 
 15271  6438 
         Object root_0 = null;
 15272   
 
 15273  6438 
         SparqlParser.var_return var337 =null;
 15274   
 
 15275  6438 
         SparqlParser.graphTerm_return graphTerm338 =null;
 15276   
 
 15277   
 
 15278   
 
 15279   
         try {
 15280   
             // com\\googlecode\\sparkleg\\Sparql.g:454:5: ( var | graphTerm )
 15281  6438 
             int alt114=2;
 15282  6438 
             switch ( input.LA(1) ) {
 15283   
             case VAR1:
 15284   
             case VAR2:
 15285   
                 {
 15286  4922 
                 alt114=1;
 15287   
                 }
 15288  4922 
                 break;
 15289   
             case BLANK_NODE_LABEL:
 15290   
             case DECIMAL:
 15291   
             case DECIMAL_NEGATIVE:
 15292   
             case DECIMAL_POSITIVE:
 15293   
             case DOUBLE:
 15294   
             case DOUBLE_NEGATIVE:
 15295   
             case DOUBLE_POSITIVE:
 15296   
             case FALSE:
 15297   
             case INTEGER:
 15298   
             case INTEGER_NEGATIVE:
 15299   
             case INTEGER_POSITIVE:
 15300   
             case IRI_REF:
 15301   
             case OPEN_BRACE:
 15302   
             case OPEN_SQUARE_BRACKET:
 15303   
             case PNAME_LN:
 15304   
             case PNAME_NS:
 15305   
             case STRING_LITERAL1:
 15306   
             case STRING_LITERAL2:
 15307   
             case STRING_LITERAL_LONG1:
 15308   
             case STRING_LITERAL_LONG2:
 15309   
             case TRUE:
 15310   
                 {
 15311  1516 
                 alt114=2;
 15312   
                 }
 15313  1516 
                 break;
 15314   
             default:
 15315  0 
                 NoViableAltException nvae =
 15316   
                     new NoViableAltException("", 114, 0, input);
 15317   
 
 15318  0 
                 throw nvae;
 15319   
 
 15320   
             }
 15321   
 
 15322  6438 
             switch (alt114) {
 15323   
                 case 1 :
 15324   
                     // com\\googlecode\\sparkleg\\Sparql.g:454:7: var
 15325   
                     {
 15326  4922 
                     root_0 = (Object)adaptor.nil();
 15327   
 
 15328   
 
 15329  4922 
                     pushFollow(FOLLOW_var_in_varOrTerm3757);
 15330  4922 
                     var337=var();
 15331   
 
 15332  4922 
                     state._fsp--;
 15333   
 
 15334  4922 
                     adaptor.addChild(root_0, var337.getTree());
 15335   
 
 15336   
                     }
 15337  4922 
                     break;
 15338   
                 case 2 :
 15339   
                     // com\\googlecode\\sparkleg\\Sparql.g:455:7: graphTerm
 15340   
                     {
 15341  1516 
                     root_0 = (Object)adaptor.nil();
 15342   
 
 15343   
 
 15344  1516 
                     pushFollow(FOLLOW_graphTerm_in_varOrTerm3765);
 15345  1516 
                     graphTerm338=graphTerm();
 15346   
 
 15347  1516 
                     state._fsp--;
 15348   
 
 15349  1516 
                     adaptor.addChild(root_0, graphTerm338.getTree());
 15350   
 
 15351   
                     }
 15352   
                     break;
 15353   
 
 15354   
             }
 15355  6438 
             retval.stop = input.LT(-1);
 15356   
 
 15357   
 
 15358  6438 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15359  6438 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15360   
 
 15361   
         }
 15362  0 
         catch (RecognitionException re) {
 15363  0 
             reportError(re);
 15364  0 
             recover(input,re);
 15365  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15366   
 
 15367   
         }
 15368   
 
 15369  0 
         finally {
 15370   
                 // do for sure before leaving
 15371  6438 
         }
 15372  6438 
         return retval;
 15373   
     }
 15374   
     // $ANTLR end "varOrTerm"
 15375   
 
 15376   
 
 15377  254 
     public static class varOrIRIref_return extends ParserRuleReturnScope {
 15378   
         Object tree;
 15379  296 
         public Object getTree() { return tree; }
 15380   
     };
 15381   
 
 15382   
 
 15383   
     // $ANTLR start "varOrIRIref"
 15384   
     // com\\googlecode\\sparkleg\\Sparql.g:458:1: varOrIRIref : ( var | iriRef );
 15385   
     public final SparqlParser.varOrIRIref_return varOrIRIref() throws RecognitionException {
 15386  254 
         SparqlParser.varOrIRIref_return retval = new SparqlParser.varOrIRIref_return();
 15387  254 
         retval.start = input.LT(1);
 15388   
 
 15389   
 
 15390  254 
         Object root_0 = null;
 15391   
 
 15392  254 
         SparqlParser.var_return var339 =null;
 15393   
 
 15394  254 
         SparqlParser.iriRef_return iriRef340 =null;
 15395   
 
 15396   
 
 15397   
 
 15398   
         try {
 15399   
             // com\\googlecode\\sparkleg\\Sparql.g:459:5: ( var | iriRef )
 15400  254 
             int alt115=2;
 15401  254 
             switch ( input.LA(1) ) {
 15402   
             case VAR1:
 15403   
             case VAR2:
 15404   
                 {
 15405  144 
                 alt115=1;
 15406   
                 }
 15407  144 
                 break;
 15408   
             case IRI_REF:
 15409   
             case PNAME_LN:
 15410   
             case PNAME_NS:
 15411   
                 {
 15412  110 
                 alt115=2;
 15413   
                 }
 15414  110 
                 break;
 15415   
             default:
 15416  0 
                 NoViableAltException nvae =
 15417   
                     new NoViableAltException("", 115, 0, input);
 15418   
 
 15419  0 
                 throw nvae;
 15420   
 
 15421   
             }
 15422   
 
 15423  254 
             switch (alt115) {
 15424   
                 case 1 :
 15425   
                     // com\\googlecode\\sparkleg\\Sparql.g:459:7: var
 15426   
                     {
 15427  144 
                     root_0 = (Object)adaptor.nil();
 15428   
 
 15429   
 
 15430  144 
                     pushFollow(FOLLOW_var_in_varOrIRIref3782);
 15431  144 
                     var339=var();
 15432   
 
 15433  144 
                     state._fsp--;
 15434   
 
 15435  144 
                     adaptor.addChild(root_0, var339.getTree());
 15436   
 
 15437   
                     }
 15438  144 
                     break;
 15439   
                 case 2 :
 15440   
                     // com\\googlecode\\sparkleg\\Sparql.g:459:13: iriRef
 15441   
                     {
 15442  110 
                     root_0 = (Object)adaptor.nil();
 15443   
 
 15444   
 
 15445  110 
                     pushFollow(FOLLOW_iriRef_in_varOrIRIref3786);
 15446  110 
                     iriRef340=iriRef();
 15447   
 
 15448  110 
                     state._fsp--;
 15449   
 
 15450  110 
                     adaptor.addChild(root_0, iriRef340.getTree());
 15451   
 
 15452   
                     }
 15453   
                     break;
 15454   
 
 15455   
             }
 15456  254 
             retval.stop = input.LT(-1);
 15457   
 
 15458   
 
 15459  254 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15460  254 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15461   
 
 15462   
         }
 15463  0 
         catch (RecognitionException re) {
 15464  0 
             reportError(re);
 15465  0 
             recover(input,re);
 15466  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15467   
 
 15468   
         }
 15469   
 
 15470  0 
         finally {
 15471   
                 // do for sure before leaving
 15472  254 
         }
 15473  254 
         return retval;
 15474   
     }
 15475   
     // $ANTLR end "varOrIRIref"
 15476   
 
 15477   
 
 15478  8906 
     public static class var_return extends ParserRuleReturnScope {
 15479   
         Object tree;
 15480  8906 
         public Object getTree() { return tree; }
 15481   
     };
 15482   
 
 15483   
 
 15484   
     // $ANTLR start "var"
 15485   
     // com\\googlecode\\sparkleg\\Sparql.g:462:1: var : ( VAR1 | VAR2 );
 15486   
     public final SparqlParser.var_return var() throws RecognitionException {
 15487  8906 
         SparqlParser.var_return retval = new SparqlParser.var_return();
 15488  8906 
         retval.start = input.LT(1);
 15489   
 
 15490   
 
 15491  8906 
         Object root_0 = null;
 15492   
 
 15493  8906 
         Token set341=null;
 15494   
 
 15495  8906 
         Object set341_tree=null;
 15496   
 
 15497   
         try {
 15498   
             // com\\googlecode\\sparkleg\\Sparql.g:463:5: ( VAR1 | VAR2 )
 15499   
             // com\\googlecode\\sparkleg\\Sparql.g:
 15500   
             {
 15501  8906 
             root_0 = (Object)adaptor.nil();
 15502   
 
 15503   
 
 15504  8906 
             set341=(Token)input.LT(1);
 15505   
 
 15506  8906 
             if ( (input.LA(1) >= VAR1 && input.LA(1) <= VAR2) ) {
 15507  8906 
                 input.consume();
 15508  8906 
                 adaptor.addChild(root_0,
 15509   
                 (Object)adaptor.create(set341)
 15510   
                 );
 15511  8906 
                 state.errorRecovery=false;
 15512   
             }
 15513   
             else {
 15514  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 15515  0 
                 throw mse;
 15516   
             }
 15517   
 
 15518   
 
 15519   
             }
 15520   
 
 15521  8906 
             retval.stop = input.LT(-1);
 15522   
 
 15523   
 
 15524  8906 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15525  8906 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15526   
 
 15527   
         }
 15528  0 
         catch (RecognitionException re) {
 15529  0 
             reportError(re);
 15530  0 
             recover(input,re);
 15531  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15532   
 
 15533   
         }
 15534   
 
 15535  0 
         finally {
 15536   
                 // do for sure before leaving
 15537  8906 
         }
 15538  8906 
         return retval;
 15539   
     }
 15540   
     // $ANTLR end "var"
 15541   
 
 15542   
 
 15543  1516 
     public static class graphTerm_return extends ParserRuleReturnScope {
 15544   
         Object tree;
 15545  1516 
         public Object getTree() { return tree; }
 15546   
     };
 15547   
 
 15548   
 
 15549   
     // $ANTLR start "graphTerm"
 15550   
     // com\\googlecode\\sparkleg\\Sparql.g:466:1: graphTerm : ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil );
 15551   
     public final SparqlParser.graphTerm_return graphTerm() throws RecognitionException {
 15552  1516 
         SparqlParser.graphTerm_return retval = new SparqlParser.graphTerm_return();
 15553  1516 
         retval.start = input.LT(1);
 15554   
 
 15555   
 
 15556  1516 
         Object root_0 = null;
 15557   
 
 15558  1516 
         SparqlParser.iriRef_return iriRef342 =null;
 15559   
 
 15560  1516 
         SparqlParser.rdfLiteral_return rdfLiteral343 =null;
 15561   
 
 15562  1516 
         SparqlParser.numericLiteral_return numericLiteral344 =null;
 15563   
 
 15564  1516 
         SparqlParser.booleanLiteral_return booleanLiteral345 =null;
 15565   
 
 15566  1516 
         SparqlParser.blankNode_return blankNode346 =null;
 15567   
 
 15568  1516 
         SparqlParser.nil_return nil347 =null;
 15569   
 
 15570   
 
 15571   
 
 15572   
         try {
 15573   
             // com\\googlecode\\sparkleg\\Sparql.g:467:5: ( iriRef | rdfLiteral | numericLiteral | booleanLiteral | blankNode | nil )
 15574  1516 
             int alt116=6;
 15575  1516 
             switch ( input.LA(1) ) {
 15576   
             case IRI_REF:
 15577   
             case PNAME_LN:
 15578   
             case PNAME_NS:
 15579   
                 {
 15580  1060 
                 alt116=1;
 15581   
                 }
 15582  1060 
                 break;
 15583   
             case STRING_LITERAL1:
 15584   
             case STRING_LITERAL2:
 15585   
             case STRING_LITERAL_LONG1:
 15586   
             case STRING_LITERAL_LONG2:
 15587   
                 {
 15588  156 
                 alt116=2;
 15589   
                 }
 15590  156 
                 break;
 15591   
             case DECIMAL:
 15592   
             case DECIMAL_NEGATIVE:
 15593   
             case DECIMAL_POSITIVE:
 15594   
             case DOUBLE:
 15595   
             case DOUBLE_NEGATIVE:
 15596   
             case DOUBLE_POSITIVE:
 15597   
             case INTEGER:
 15598   
             case INTEGER_NEGATIVE:
 15599   
             case INTEGER_POSITIVE:
 15600   
                 {
 15601  94 
                 alt116=3;
 15602   
                 }
 15603  94 
                 break;
 15604   
             case FALSE:
 15605   
             case TRUE:
 15606   
                 {
 15607  4 
                 alt116=4;
 15608   
                 }
 15609  4 
                 break;
 15610   
             case BLANK_NODE_LABEL:
 15611   
             case OPEN_SQUARE_BRACKET:
 15612   
                 {
 15613  192 
                 alt116=5;
 15614   
                 }
 15615  192 
                 break;
 15616   
             case OPEN_BRACE:
 15617   
                 {
 15618  10 
                 alt116=6;
 15619   
                 }
 15620  10 
                 break;
 15621   
             default:
 15622  0 
                 NoViableAltException nvae =
 15623   
                     new NoViableAltException("", 116, 0, input);
 15624   
 
 15625  0 
                 throw nvae;
 15626   
 
 15627   
             }
 15628   
 
 15629  1516 
             switch (alt116) {
 15630   
                 case 1 :
 15631   
                     // com\\googlecode\\sparkleg\\Sparql.g:467:7: iriRef
 15632   
                     {
 15633  1060 
                     root_0 = (Object)adaptor.nil();
 15634   
 
 15635   
 
 15636  1060 
                     pushFollow(FOLLOW_iriRef_in_graphTerm3824);
 15637  1060 
                     iriRef342=iriRef();
 15638   
 
 15639  1060 
                     state._fsp--;
 15640   
 
 15641  1060 
                     adaptor.addChild(root_0, iriRef342.getTree());
 15642   
 
 15643   
                     }
 15644  1060 
                     break;
 15645   
                 case 2 :
 15646   
                     // com\\googlecode\\sparkleg\\Sparql.g:468:7: rdfLiteral
 15647   
                     {
 15648  156 
                     root_0 = (Object)adaptor.nil();
 15649   
 
 15650   
 
 15651  156 
                     pushFollow(FOLLOW_rdfLiteral_in_graphTerm3832);
 15652  156 
                     rdfLiteral343=rdfLiteral();
 15653   
 
 15654  156 
                     state._fsp--;
 15655   
 
 15656  156 
                     adaptor.addChild(root_0, rdfLiteral343.getTree());
 15657   
 
 15658   
                     }
 15659  156 
                     break;
 15660   
                 case 3 :
 15661   
                     // com\\googlecode\\sparkleg\\Sparql.g:469:7: numericLiteral
 15662   
                     {
 15663  94 
                     root_0 = (Object)adaptor.nil();
 15664   
 
 15665   
 
 15666  94 
                     pushFollow(FOLLOW_numericLiteral_in_graphTerm3840);
 15667  94 
                     numericLiteral344=numericLiteral();
 15668   
 
 15669  94 
                     state._fsp--;
 15670   
 
 15671  94 
                     adaptor.addChild(root_0, numericLiteral344.getTree());
 15672   
 
 15673   
                     }
 15674  94 
                     break;
 15675   
                 case 4 :
 15676   
                     // com\\googlecode\\sparkleg\\Sparql.g:470:7: booleanLiteral
 15677   
                     {
 15678  4 
                     root_0 = (Object)adaptor.nil();
 15679   
 
 15680   
 
 15681  4 
                     pushFollow(FOLLOW_booleanLiteral_in_graphTerm3848);
 15682  4 
                     booleanLiteral345=booleanLiteral();
 15683   
 
 15684  4 
                     state._fsp--;
 15685   
 
 15686  4 
                     adaptor.addChild(root_0, booleanLiteral345.getTree());
 15687   
 
 15688   
                     }
 15689  4 
                     break;
 15690   
                 case 5 :
 15691   
                     // com\\googlecode\\sparkleg\\Sparql.g:471:7: blankNode
 15692   
                     {
 15693  192 
                     root_0 = (Object)adaptor.nil();
 15694   
 
 15695   
 
 15696  192 
                     pushFollow(FOLLOW_blankNode_in_graphTerm3856);
 15697  192 
                     blankNode346=blankNode();
 15698   
 
 15699  192 
                     state._fsp--;
 15700   
 
 15701  192 
                     adaptor.addChild(root_0, blankNode346.getTree());
 15702   
 
 15703   
                     }
 15704  192 
                     break;
 15705   
                 case 6 :
 15706   
                     // com\\googlecode\\sparkleg\\Sparql.g:472:7: nil
 15707   
                     {
 15708  10 
                     root_0 = (Object)adaptor.nil();
 15709   
 
 15710   
 
 15711  10 
                     pushFollow(FOLLOW_nil_in_graphTerm3864);
 15712  10 
                     nil347=nil();
 15713   
 
 15714  10 
                     state._fsp--;
 15715   
 
 15716  10 
                     adaptor.addChild(root_0, nil347.getTree());
 15717   
 
 15718   
                     }
 15719   
                     break;
 15720   
 
 15721   
             }
 15722  1516 
             retval.stop = input.LT(-1);
 15723   
 
 15724   
 
 15725  1516 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15726  1516 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15727   
 
 15728   
         }
 15729  0 
         catch (RecognitionException re) {
 15730  0 
             reportError(re);
 15731  0 
             recover(input,re);
 15732  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15733   
 
 15734   
         }
 15735   
 
 15736  0 
         finally {
 15737   
                 // do for sure before leaving
 15738  1516 
         }
 15739  1516 
         return retval;
 15740   
     }
 15741   
     // $ANTLR end "graphTerm"
 15742   
 
 15743   
 
 15744  91 
     public static class nil_return extends ParserRuleReturnScope {
 15745   
         Object tree;
 15746  91 
         public Object getTree() { return tree; }
 15747   
     };
 15748   
 
 15749   
 
 15750   
     // $ANTLR start "nil"
 15751   
     // com\\googlecode\\sparkleg\\Sparql.g:475:1: nil : OPEN_BRACE CLOSE_BRACE ;
 15752   
     public final SparqlParser.nil_return nil() throws RecognitionException {
 15753  91 
         SparqlParser.nil_return retval = new SparqlParser.nil_return();
 15754  91 
         retval.start = input.LT(1);
 15755   
 
 15756   
 
 15757  91 
         Object root_0 = null;
 15758   
 
 15759  91 
         Token OPEN_BRACE348=null;
 15760  91 
         Token CLOSE_BRACE349=null;
 15761   
 
 15762  91 
         Object OPEN_BRACE348_tree=null;
 15763  91 
         Object CLOSE_BRACE349_tree=null;
 15764   
 
 15765   
         try {
 15766   
             // com\\googlecode\\sparkleg\\Sparql.g:476:5: ( OPEN_BRACE CLOSE_BRACE )
 15767   
             // com\\googlecode\\sparkleg\\Sparql.g:476:7: OPEN_BRACE CLOSE_BRACE
 15768   
             {
 15769  91 
             root_0 = (Object)adaptor.nil();
 15770   
 
 15771   
 
 15772  91 
             OPEN_BRACE348=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_nil3885);
 15773  91 
             OPEN_BRACE348_tree =
 15774   
             (Object)adaptor.create(OPEN_BRACE348)
 15775   
             ;
 15776  91 
             adaptor.addChild(root_0, OPEN_BRACE348_tree);
 15777   
 
 15778   
 
 15779  91 
             CLOSE_BRACE349=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_nil3887);
 15780  91 
             CLOSE_BRACE349_tree =
 15781   
             (Object)adaptor.create(CLOSE_BRACE349)
 15782   
             ;
 15783  91 
             adaptor.addChild(root_0, CLOSE_BRACE349_tree);
 15784   
 
 15785   
 
 15786   
             }
 15787   
 
 15788  91 
             retval.stop = input.LT(-1);
 15789   
 
 15790   
 
 15791  91 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15792  91 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15793   
 
 15794   
         }
 15795  0 
         catch (RecognitionException re) {
 15796  0 
             reportError(re);
 15797  0 
             recover(input,re);
 15798  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15799   
 
 15800   
         }
 15801   
 
 15802  0 
         finally {
 15803   
                 // do for sure before leaving
 15804  91 
         }
 15805  91 
         return retval;
 15806   
     }
 15807   
     // $ANTLR end "nil"
 15808   
 
 15809   
 
 15810  1640 
     public static class expression_return extends ParserRuleReturnScope {
 15811   
         Object tree;
 15812  1640 
         public Object getTree() { return tree; }
 15813   
     };
 15814   
 
 15815   
 
 15816   
     // $ANTLR start "expression"
 15817   
     // com\\googlecode\\sparkleg\\Sparql.g:479:1: expression : conditionalOrExpression ;
 15818   
     public final SparqlParser.expression_return expression() throws RecognitionException {
 15819  1640 
         SparqlParser.expression_return retval = new SparqlParser.expression_return();
 15820  1640 
         retval.start = input.LT(1);
 15821   
 
 15822   
 
 15823  1640 
         Object root_0 = null;
 15824   
 
 15825  1640 
         SparqlParser.conditionalOrExpression_return conditionalOrExpression350 =null;
 15826   
 
 15827   
 
 15828   
 
 15829   
         try {
 15830   
             // com\\googlecode\\sparkleg\\Sparql.g:480:5: ( conditionalOrExpression )
 15831   
             // com\\googlecode\\sparkleg\\Sparql.g:480:7: conditionalOrExpression
 15832   
             {
 15833  1640 
             root_0 = (Object)adaptor.nil();
 15834   
 
 15835   
 
 15836  1640 
             pushFollow(FOLLOW_conditionalOrExpression_in_expression3904);
 15837  1640 
             conditionalOrExpression350=conditionalOrExpression();
 15838   
 
 15839  1640 
             state._fsp--;
 15840   
 
 15841  1640 
             adaptor.addChild(root_0, conditionalOrExpression350.getTree());
 15842   
 
 15843   
             }
 15844   
 
 15845  1640 
             retval.stop = input.LT(-1);
 15846   
 
 15847   
 
 15848  1640 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 15849  1640 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 15850   
 
 15851   
         }
 15852  0 
         catch (RecognitionException re) {
 15853  0 
             reportError(re);
 15854  0 
             recover(input,re);
 15855  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 15856   
 
 15857   
         }
 15858   
 
 15859  0 
         finally {
 15860   
                 // do for sure before leaving
 15861  1640 
         }
 15862  1640 
         return retval;
 15863   
     }
 15864   
     // $ANTLR end "expression"
 15865   
 
 15866   
 
 15867  1640 
     public static class conditionalOrExpression_return extends ParserRuleReturnScope {
 15868   
         Object tree;
 15869  1640 
         public Object getTree() { return tree; }
 15870   
     };
 15871   
 
 15872   
 
 15873   
     // $ANTLR start "conditionalOrExpression"
 15874   
     // com\\googlecode\\sparkleg\\Sparql.g:483:1: conditionalOrExpression : (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* ;
 15875   
     public final SparqlParser.conditionalOrExpression_return conditionalOrExpression() throws RecognitionException {
 15876  1640 
         SparqlParser.conditionalOrExpression_return retval = new SparqlParser.conditionalOrExpression_return();
 15877  1640 
         retval.start = input.LT(1);
 15878   
 
 15879   
 
 15880  1640 
         Object root_0 = null;
 15881   
 
 15882  1640 
         Token OR351=null;
 15883  1640 
         SparqlParser.conditionalAndExpression_return c1 =null;
 15884   
 
 15885  1640 
         SparqlParser.conditionalAndExpression_return c2 =null;
 15886   
 
 15887   
 
 15888  1640 
         Object OR351_tree=null;
 15889  1640 
         RewriteRuleTokenStream stream_OR=new RewriteRuleTokenStream(adaptor,"token OR");
 15890  1640 
         RewriteRuleSubtreeStream stream_conditionalAndExpression=new RewriteRuleSubtreeStream(adaptor,"rule conditionalAndExpression");
 15891   
         try {
 15892   
             // com\\googlecode\\sparkleg\\Sparql.g:484:5: ( (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )* )
 15893   
             // com\\googlecode\\sparkleg\\Sparql.g:484:7: (c1= conditionalAndExpression -> $c1) ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15894   
             {
 15895   
             // com\\googlecode\\sparkleg\\Sparql.g:484:7: (c1= conditionalAndExpression -> $c1)
 15896   
             // com\\googlecode\\sparkleg\\Sparql.g:484:8: c1= conditionalAndExpression
 15897   
             {
 15898  1640 
             pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3924);
 15899  1640 
             c1=conditionalAndExpression();
 15900   
 
 15901  1640 
             state._fsp--;
 15902   
 
 15903  1640 
             stream_conditionalAndExpression.add(c1.getTree());
 15904   
 
 15905   
             // AST REWRITE
 15906   
             // elements: c1
 15907   
             // token labels:
 15908   
             // rule labels: retval, c1
 15909   
             // token list labels:
 15910   
             // rule list labels:
 15911   
             // wildcard labels:
 15912  1640 
             retval.tree = root_0;
 15913  1640 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15914  1640 
             RewriteRuleSubtreeStream stream_c1=new RewriteRuleSubtreeStream(adaptor,"rule c1",c1!=null?c1.tree:null);
 15915   
 
 15916  1640 
             root_0 = (Object)adaptor.nil();
 15917   
             // 484:36: -> $c1
 15918   
             {
 15919  1640 
                 adaptor.addChild(root_0, stream_c1.nextTree());
 15920   
 
 15921   
             }
 15922   
 
 15923   
 
 15924  1640 
             retval.tree = root_0;
 15925   
 
 15926   
             }
 15927   
 
 15928   
 
 15929   
             // com\\googlecode\\sparkleg\\Sparql.g:484:44: ( OR c2= conditionalAndExpression -> ^( OR $conditionalOrExpression $c2) )*
 15930   
             loop117:
 15931   
             do {
 15932  1688 
                 int alt117=2;
 15933  1688 
                 switch ( input.LA(1) ) {
 15934   
                 case OR:
 15935   
                     {
 15936  48 
                     alt117=1;
 15937   
                     }
 15938   
                     break;
 15939   
 
 15940   
                 }
 15941   
 
 15942  1688 
                 switch (alt117) {
 15943   
                     case 1 :
 15944   
                         // com\\googlecode\\sparkleg\\Sparql.g:484:45: OR c2= conditionalAndExpression
 15945   
                         {
 15946  48 
                         OR351=(Token)match(input,OR,FOLLOW_OR_in_conditionalOrExpression3933);
 15947  48 
                         stream_OR.add(OR351);
 15948   
 
 15949   
 
 15950  48 
                         pushFollow(FOLLOW_conditionalAndExpression_in_conditionalOrExpression3937);
 15951  48 
                         c2=conditionalAndExpression();
 15952   
 
 15953  48 
                         state._fsp--;
 15954   
 
 15955  48 
                         stream_conditionalAndExpression.add(c2.getTree());
 15956   
 
 15957   
                         // AST REWRITE
 15958   
                         // elements: conditionalOrExpression, OR, c2
 15959   
                         // token labels:
 15960   
                         // rule labels: retval, c2
 15961   
                         // token list labels:
 15962   
                         // rule list labels:
 15963   
                         // wildcard labels:
 15964  48 
                         retval.tree = root_0;
 15965  48 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 15966  48 
                         RewriteRuleSubtreeStream stream_c2=new RewriteRuleSubtreeStream(adaptor,"rule c2",c2!=null?c2.tree:null);
 15967   
 
 15968  48 
                         root_0 = (Object)adaptor.nil();
 15969   
                         // 484:76: -> ^( OR $conditionalOrExpression $c2)
 15970   
                         {
 15971   
                             // com\\googlecode\\sparkleg\\Sparql.g:484:79: ^( OR $conditionalOrExpression $c2)
 15972   
                             {
 15973  48 
                             Object root_1 = (Object)adaptor.nil();
 15974  48 
                             root_1 = (Object)adaptor.becomeRoot(
 15975   
                             stream_OR.nextNode()
 15976   
                             , root_1);
 15977   
 
 15978  48 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 15979   
 
 15980  48 
                             adaptor.addChild(root_1, stream_c2.nextTree());
 15981   
 
 15982  48 
                             adaptor.addChild(root_0, root_1);
 15983   
                             }
 15984   
 
 15985   
                         }
 15986   
 
 15987   
 
 15988  48 
                         retval.tree = root_0;
 15989   
 
 15990   
                         }
 15991  48 
                         break;
 15992   
 
 15993   
                     default :
 15994  1640 
                         break loop117;
 15995   
                 }
 15996  48 
             } while (true);
 15997   
 
 15998   
 
 15999   
             }
 16000   
 
 16001  1640 
             retval.stop = input.LT(-1);
 16002   
 
 16003   
 
 16004  1640 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16005  1640 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16006   
 
 16007   
         }
 16008  0 
         catch (RecognitionException re) {
 16009  0 
             reportError(re);
 16010  0 
             recover(input,re);
 16011  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16012   
 
 16013   
         }
 16014   
 
 16015  0 
         finally {
 16016   
                 // do for sure before leaving
 16017  1640 
         }
 16018  1640 
         return retval;
 16019   
     }
 16020   
     // $ANTLR end "conditionalOrExpression"
 16021   
 
 16022   
 
 16023  1688 
     public static class conditionalAndExpression_return extends ParserRuleReturnScope {
 16024   
         Object tree;
 16025  1688 
         public Object getTree() { return tree; }
 16026   
     };
 16027   
 
 16028   
 
 16029   
     // $ANTLR start "conditionalAndExpression"
 16030   
     // com\\googlecode\\sparkleg\\Sparql.g:487:1: conditionalAndExpression : (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* ;
 16031   
     public final SparqlParser.conditionalAndExpression_return conditionalAndExpression() throws RecognitionException {
 16032  1688 
         SparqlParser.conditionalAndExpression_return retval = new SparqlParser.conditionalAndExpression_return();
 16033  1688 
         retval.start = input.LT(1);
 16034   
 
 16035   
 
 16036  1688 
         Object root_0 = null;
 16037   
 
 16038  1688 
         Token AND352=null;
 16039  1688 
         SparqlParser.valueLogical_return v1 =null;
 16040   
 
 16041  1688 
         SparqlParser.valueLogical_return v2 =null;
 16042   
 
 16043   
 
 16044  1688 
         Object AND352_tree=null;
 16045  1688 
         RewriteRuleTokenStream stream_AND=new RewriteRuleTokenStream(adaptor,"token AND");
 16046  1688 
         RewriteRuleSubtreeStream stream_valueLogical=new RewriteRuleSubtreeStream(adaptor,"rule valueLogical");
 16047   
         try {
 16048   
             // com\\googlecode\\sparkleg\\Sparql.g:488:5: ( (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )* )
 16049   
             // com\\googlecode\\sparkleg\\Sparql.g:488:7: (v1= valueLogical -> $v1) ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 16050   
             {
 16051   
             // com\\googlecode\\sparkleg\\Sparql.g:488:7: (v1= valueLogical -> $v1)
 16052   
             // com\\googlecode\\sparkleg\\Sparql.g:488:8: v1= valueLogical
 16053   
             {
 16054  1688 
             pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3971);
 16055  1688 
             v1=valueLogical();
 16056   
 
 16057  1688 
             state._fsp--;
 16058   
 
 16059  1688 
             stream_valueLogical.add(v1.getTree());
 16060   
 
 16061   
             // AST REWRITE
 16062   
             // elements: v1
 16063   
             // token labels:
 16064   
             // rule labels: v1, retval
 16065   
             // token list labels:
 16066   
             // rule list labels:
 16067   
             // wildcard labels:
 16068  1688 
             retval.tree = root_0;
 16069  1688 
             RewriteRuleSubtreeStream stream_v1=new RewriteRuleSubtreeStream(adaptor,"rule v1",v1!=null?v1.tree:null);
 16070  1688 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16071   
 
 16072  1688 
             root_0 = (Object)adaptor.nil();
 16073   
             // 488:24: -> $v1
 16074   
             {
 16075  1688 
                 adaptor.addChild(root_0, stream_v1.nextTree());
 16076   
 
 16077   
             }
 16078   
 
 16079   
 
 16080  1688 
             retval.tree = root_0;
 16081   
 
 16082   
             }
 16083   
 
 16084   
 
 16085   
             // com\\googlecode\\sparkleg\\Sparql.g:488:32: ( AND v2= valueLogical -> ^( AND $conditionalAndExpression $v2) )*
 16086   
             loop118:
 16087   
             do {
 16088  1736 
                 int alt118=2;
 16089  1736 
                 switch ( input.LA(1) ) {
 16090   
                 case AND:
 16091   
                     {
 16092  48 
                     alt118=1;
 16093   
                     }
 16094   
                     break;
 16095   
 
 16096   
                 }
 16097   
 
 16098  1736 
                 switch (alt118) {
 16099   
                     case 1 :
 16100   
                         // com\\googlecode\\sparkleg\\Sparql.g:488:33: AND v2= valueLogical
 16101   
                         {
 16102  48 
                         AND352=(Token)match(input,AND,FOLLOW_AND_in_conditionalAndExpression3980);
 16103  48 
                         stream_AND.add(AND352);
 16104   
 
 16105   
 
 16106  48 
                         pushFollow(FOLLOW_valueLogical_in_conditionalAndExpression3984);
 16107  48 
                         v2=valueLogical();
 16108   
 
 16109  48 
                         state._fsp--;
 16110   
 
 16111  48 
                         stream_valueLogical.add(v2.getTree());
 16112   
 
 16113   
                         // AST REWRITE
 16114   
                         // elements: AND, v2, conditionalAndExpression
 16115   
                         // token labels:
 16116   
                         // rule labels: retval, v2
 16117   
                         // token list labels:
 16118   
                         // rule list labels:
 16119   
                         // wildcard labels:
 16120  48 
                         retval.tree = root_0;
 16121  48 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16122  48 
                         RewriteRuleSubtreeStream stream_v2=new RewriteRuleSubtreeStream(adaptor,"rule v2",v2!=null?v2.tree:null);
 16123   
 
 16124  48 
                         root_0 = (Object)adaptor.nil();
 16125   
                         // 488:53: -> ^( AND $conditionalAndExpression $v2)
 16126   
                         {
 16127   
                             // com\\googlecode\\sparkleg\\Sparql.g:488:56: ^( AND $conditionalAndExpression $v2)
 16128   
                             {
 16129  48 
                             Object root_1 = (Object)adaptor.nil();
 16130  48 
                             root_1 = (Object)adaptor.becomeRoot(
 16131   
                             stream_AND.nextNode()
 16132   
                             , root_1);
 16133   
 
 16134  48 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 16135   
 
 16136  48 
                             adaptor.addChild(root_1, stream_v2.nextTree());
 16137   
 
 16138  48 
                             adaptor.addChild(root_0, root_1);
 16139   
                             }
 16140   
 
 16141   
                         }
 16142   
 
 16143   
 
 16144  48 
                         retval.tree = root_0;
 16145   
 
 16146   
                         }
 16147  48 
                         break;
 16148   
 
 16149   
                     default :
 16150  1688 
                         break loop118;
 16151   
                 }
 16152  48 
             } while (true);
 16153   
 
 16154   
 
 16155   
             }
 16156   
 
 16157  1688 
             retval.stop = input.LT(-1);
 16158   
 
 16159   
 
 16160  1688 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16161  1688 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16162   
 
 16163   
         }
 16164  0 
         catch (RecognitionException re) {
 16165  0 
             reportError(re);
 16166  0 
             recover(input,re);
 16167  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16168   
 
 16169   
         }
 16170   
 
 16171  0 
         finally {
 16172   
                 // do for sure before leaving
 16173  1688 
         }
 16174  1688 
         return retval;
 16175   
     }
 16176   
     // $ANTLR end "conditionalAndExpression"
 16177   
 
 16178   
 
 16179  1736 
     public static class valueLogical_return extends ParserRuleReturnScope {
 16180   
         Object tree;
 16181  1736 
         public Object getTree() { return tree; }
 16182   
     };
 16183   
 
 16184   
 
 16185   
     // $ANTLR start "valueLogical"
 16186   
     // com\\googlecode\\sparkleg\\Sparql.g:491:1: valueLogical : relationalExpression ;
 16187   
     public final SparqlParser.valueLogical_return valueLogical() throws RecognitionException {
 16188  1736 
         SparqlParser.valueLogical_return retval = new SparqlParser.valueLogical_return();
 16189  1736 
         retval.start = input.LT(1);
 16190   
 
 16191   
 
 16192  1736 
         Object root_0 = null;
 16193   
 
 16194  1736 
         SparqlParser.relationalExpression_return relationalExpression353 =null;
 16195   
 
 16196   
 
 16197   
 
 16198   
         try {
 16199   
             // com\\googlecode\\sparkleg\\Sparql.g:492:5: ( relationalExpression )
 16200   
             // com\\googlecode\\sparkleg\\Sparql.g:492:7: relationalExpression
 16201   
             {
 16202  1736 
             root_0 = (Object)adaptor.nil();
 16203   
 
 16204   
 
 16205  1736 
             pushFollow(FOLLOW_relationalExpression_in_valueLogical4015);
 16206  1736 
             relationalExpression353=relationalExpression();
 16207   
 
 16208  1736 
             state._fsp--;
 16209   
 
 16210  1736 
             adaptor.addChild(root_0, relationalExpression353.getTree());
 16211   
 
 16212   
             }
 16213   
 
 16214  1736 
             retval.stop = input.LT(-1);
 16215   
 
 16216   
 
 16217  1736 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16218  1736 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16219   
 
 16220   
         }
 16221  0 
         catch (RecognitionException re) {
 16222  0 
             reportError(re);
 16223  0 
             recover(input,re);
 16224  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16225   
 
 16226   
         }
 16227   
 
 16228  0 
         finally {
 16229   
                 // do for sure before leaving
 16230  1736 
         }
 16231  1736 
         return retval;
 16232   
     }
 16233   
     // $ANTLR end "valueLogical"
 16234   
 
 16235   
 
 16236  1736 
     public static class relationalExpression_return extends ParserRuleReturnScope {
 16237   
         Object tree;
 16238  1736 
         public Object getTree() { return tree; }
 16239   
     };
 16240   
 
 16241   
 
 16242   
     // $ANTLR start "relationalExpression"
 16243   
     // com\\googlecode\\sparkleg\\Sparql.g:495:1: relationalExpression : (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? ;
 16244   
     public final SparqlParser.relationalExpression_return relationalExpression() throws RecognitionException {
 16245  1736 
         SparqlParser.relationalExpression_return retval = new SparqlParser.relationalExpression_return();
 16246  1736 
         retval.start = input.LT(1);
 16247   
 
 16248   
 
 16249  1736 
         Object root_0 = null;
 16250   
 
 16251  1736 
         Token EQUAL354=null;
 16252  1736 
         Token NOT_EQUAL355=null;
 16253  1736 
         Token LESS356=null;
 16254  1736 
         Token GREATER357=null;
 16255  1736 
         Token LESS_EQUAL358=null;
 16256  1736 
         Token GREATER_EQUAL359=null;
 16257  1736 
         Token IN360=null;
 16258  1736 
         Token NOT361=null;
 16259  1736 
         Token IN362=null;
 16260  1736 
         SparqlParser.numericExpression_return n1 =null;
 16261   
 
 16262  1736 
         SparqlParser.numericExpression_return n2 =null;
 16263   
 
 16264  1736 
         SparqlParser.numericExpression_return n3 =null;
 16265   
 
 16266  1736 
         SparqlParser.numericExpression_return n4 =null;
 16267   
 
 16268  1736 
         SparqlParser.numericExpression_return n5 =null;
 16269   
 
 16270  1736 
         SparqlParser.numericExpression_return n6 =null;
 16271   
 
 16272  1736 
         SparqlParser.numericExpression_return n7 =null;
 16273   
 
 16274  1736 
         SparqlParser.expressionList_return l2 =null;
 16275   
 
 16276  1736 
         SparqlParser.expressionList_return l3 =null;
 16277   
 
 16278   
 
 16279  1736 
         Object EQUAL354_tree=null;
 16280  1736 
         Object NOT_EQUAL355_tree=null;
 16281  1736 
         Object LESS356_tree=null;
 16282  1736 
         Object GREATER357_tree=null;
 16283  1736 
         Object LESS_EQUAL358_tree=null;
 16284  1736 
         Object GREATER_EQUAL359_tree=null;
 16285  1736 
         Object IN360_tree=null;
 16286  1736 
         Object NOT361_tree=null;
 16287  1736 
         Object IN362_tree=null;
 16288  1736 
         RewriteRuleTokenStream stream_GREATER=new RewriteRuleTokenStream(adaptor,"token GREATER");
 16289  1736 
         RewriteRuleTokenStream stream_LESS_EQUAL=new RewriteRuleTokenStream(adaptor,"token LESS_EQUAL");
 16290  1736 
         RewriteRuleTokenStream stream_IN=new RewriteRuleTokenStream(adaptor,"token IN");
 16291  1736 
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 16292  1736 
         RewriteRuleTokenStream stream_NOT_EQUAL=new RewriteRuleTokenStream(adaptor,"token NOT_EQUAL");
 16293  1736 
         RewriteRuleTokenStream stream_GREATER_EQUAL=new RewriteRuleTokenStream(adaptor,"token GREATER_EQUAL");
 16294  1736 
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 16295  1736 
         RewriteRuleTokenStream stream_LESS=new RewriteRuleTokenStream(adaptor,"token LESS");
 16296  1736 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 16297  1736 
         RewriteRuleSubtreeStream stream_numericExpression=new RewriteRuleSubtreeStream(adaptor,"rule numericExpression");
 16298   
         try {
 16299   
             // com\\googlecode\\sparkleg\\Sparql.g:496:5: ( (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )? )
 16300   
             // com\\googlecode\\sparkleg\\Sparql.g:496:7: (n1= numericExpression -> $n1) ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16301   
             {
 16302   
             // com\\googlecode\\sparkleg\\Sparql.g:496:7: (n1= numericExpression -> $n1)
 16303   
             // com\\googlecode\\sparkleg\\Sparql.g:496:8: n1= numericExpression
 16304   
             {
 16305  1736 
             pushFollow(FOLLOW_numericExpression_in_relationalExpression4035);
 16306  1736 
             n1=numericExpression();
 16307   
 
 16308  1736 
             state._fsp--;
 16309   
 
 16310  1736 
             stream_numericExpression.add(n1.getTree());
 16311   
 
 16312   
             // AST REWRITE
 16313   
             // elements: n1
 16314   
             // token labels:
 16315   
             // rule labels: n1, retval
 16316   
             // token list labels:
 16317   
             // rule list labels:
 16318   
             // wildcard labels:
 16319  1736 
             retval.tree = root_0;
 16320  1736 
             RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 16321  1736 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16322   
 
 16323  1736 
             root_0 = (Object)adaptor.nil();
 16324   
             // 496:29: -> $n1
 16325   
             {
 16326  1736 
                 adaptor.addChild(root_0, stream_n1.nextTree());
 16327   
 
 16328   
             }
 16329   
 
 16330   
 
 16331  1736 
             retval.tree = root_0;
 16332   
 
 16333   
             }
 16334   
 
 16335   
 
 16336   
             // com\\googlecode\\sparkleg\\Sparql.g:496:37: ( ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) ) | ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) ) | ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) ) | ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) ) | ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) ) | ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) ) | ( IN l2= expressionList -> ^( IN $relationalExpression $l2) ) | ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) ) )?
 16337  1736 
             int alt119=9;
 16338  1736 
             switch ( input.LA(1) ) {
 16339   
                 case EQUAL:
 16340   
                     {
 16341  276 
                     alt119=1;
 16342   
                     }
 16343  276 
                     break;
 16344   
                 case NOT_EQUAL:
 16345   
                     {
 16346  56 
                     alt119=2;
 16347   
                     }
 16348  56 
                     break;
 16349   
                 case LESS:
 16350   
                     {
 16351  36 
                     alt119=3;
 16352   
                     }
 16353  36 
                     break;
 16354   
                 case GREATER:
 16355   
                     {
 16356  36 
                     alt119=4;
 16357   
                     }
 16358  36 
                     break;
 16359   
                 case LESS_EQUAL:
 16360   
                     {
 16361  4 
                     alt119=5;
 16362   
                     }
 16363  4 
                     break;
 16364   
                 case GREATER_EQUAL:
 16365   
                     {
 16366  6 
                     alt119=6;
 16367   
                     }
 16368  6 
                     break;
 16369   
                 case IN:
 16370   
                     {
 16371  4 
                     alt119=7;
 16372   
                     }
 16373  4 
                     break;
 16374   
                 case NOT:
 16375   
                     {
 16376  4 
                     alt119=8;
 16377   
                     }
 16378   
                     break;
 16379   
             }
 16380   
 
 16381  1736 
             switch (alt119) {
 16382   
                 case 1 :
 16383   
                     // com\\googlecode\\sparkleg\\Sparql.g:496:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16384   
                     {
 16385   
                     // com\\googlecode\\sparkleg\\Sparql.g:496:38: ( EQUAL n2= numericExpression -> ^( EQUAL $relationalExpression $n2) )
 16386   
                     // com\\googlecode\\sparkleg\\Sparql.g:496:39: EQUAL n2= numericExpression
 16387   
                     {
 16388  276 
                     EQUAL354=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_relationalExpression4045);
 16389  276 
                     stream_EQUAL.add(EQUAL354);
 16390   
 
 16391   
 
 16392  276 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4049);
 16393  276 
                     n2=numericExpression();
 16394   
 
 16395  276 
                     state._fsp--;
 16396   
 
 16397  276 
                     stream_numericExpression.add(n2.getTree());
 16398   
 
 16399   
                     // AST REWRITE
 16400   
                     // elements: EQUAL, relationalExpression, n2
 16401   
                     // token labels:
 16402   
                     // rule labels: retval, n2
 16403   
                     // token list labels:
 16404   
                     // rule list labels:
 16405   
                     // wildcard labels:
 16406  276 
                     retval.tree = root_0;
 16407  276 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16408  276 
                     RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 16409   
 
 16410  276 
                     root_0 = (Object)adaptor.nil();
 16411   
                     // 496:66: -> ^( EQUAL $relationalExpression $n2)
 16412   
                     {
 16413   
                         // com\\googlecode\\sparkleg\\Sparql.g:496:69: ^( EQUAL $relationalExpression $n2)
 16414   
                         {
 16415  276 
                         Object root_1 = (Object)adaptor.nil();
 16416  276 
                         root_1 = (Object)adaptor.becomeRoot(
 16417   
                         stream_EQUAL.nextNode()
 16418   
                         , root_1);
 16419   
 
 16420  276 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16421   
 
 16422  276 
                         adaptor.addChild(root_1, stream_n2.nextTree());
 16423   
 
 16424  276 
                         adaptor.addChild(root_0, root_1);
 16425   
                         }
 16426   
 
 16427   
                     }
 16428   
 
 16429   
 
 16430  276 
                     retval.tree = root_0;
 16431   
 
 16432   
                     }
 16433   
 
 16434   
 
 16435   
                     }
 16436  276 
                     break;
 16437   
                 case 2 :
 16438   
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16439   
                     {
 16440   
                     // com\\googlecode\\sparkleg\\Sparql.g:497:39: ( NOT_EQUAL n3= numericExpression -> ^( NOT_EQUAL $relationalExpression $n3) )
 16441   
                     // com\\googlecode\\sparkleg\\Sparql.g:497:40: NOT_EQUAL n3= numericExpression
 16442   
                     {
 16443  56 
                     NOT_EQUAL355=(Token)match(input,NOT_EQUAL,FOLLOW_NOT_EQUAL_in_relationalExpression4106);
 16444  56 
                     stream_NOT_EQUAL.add(NOT_EQUAL355);
 16445   
 
 16446   
 
 16447  56 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4110);
 16448  56 
                     n3=numericExpression();
 16449   
 
 16450  56 
                     state._fsp--;
 16451   
 
 16452  56 
                     stream_numericExpression.add(n3.getTree());
 16453   
 
 16454   
                     // AST REWRITE
 16455   
                     // elements: n3, relationalExpression, NOT_EQUAL
 16456   
                     // token labels:
 16457   
                     // rule labels: retval, n3
 16458   
                     // token list labels:
 16459   
                     // rule list labels:
 16460   
                     // wildcard labels:
 16461  56 
                     retval.tree = root_0;
 16462  56 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16463  56 
                     RewriteRuleSubtreeStream stream_n3=new RewriteRuleSubtreeStream(adaptor,"rule n3",n3!=null?n3.tree:null);
 16464   
 
 16465  56 
                     root_0 = (Object)adaptor.nil();
 16466   
                     // 497:71: -> ^( NOT_EQUAL $relationalExpression $n3)
 16467   
                     {
 16468   
                         // com\\googlecode\\sparkleg\\Sparql.g:497:74: ^( NOT_EQUAL $relationalExpression $n3)
 16469   
                         {
 16470  56 
                         Object root_1 = (Object)adaptor.nil();
 16471  56 
                         root_1 = (Object)adaptor.becomeRoot(
 16472   
                         stream_NOT_EQUAL.nextNode()
 16473   
                         , root_1);
 16474   
 
 16475  56 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16476   
 
 16477  56 
                         adaptor.addChild(root_1, stream_n3.nextTree());
 16478   
 
 16479  56 
                         adaptor.addChild(root_0, root_1);
 16480   
                         }
 16481   
 
 16482   
                     }
 16483   
 
 16484   
 
 16485  56 
                     retval.tree = root_0;
 16486   
 
 16487   
                     }
 16488   
 
 16489   
 
 16490   
                     }
 16491  56 
                     break;
 16492   
                 case 3 :
 16493   
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16494   
                     {
 16495   
                     // com\\googlecode\\sparkleg\\Sparql.g:498:39: ( LESS n4= numericExpression -> ^( LESS $relationalExpression $n4) )
 16496   
                     // com\\googlecode\\sparkleg\\Sparql.g:498:40: LESS n4= numericExpression
 16497   
                     {
 16498  36 
                     LESS356=(Token)match(input,LESS,FOLLOW_LESS_in_relationalExpression4165);
 16499  36 
                     stream_LESS.add(LESS356);
 16500   
 
 16501   
 
 16502  36 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4169);
 16503  36 
                     n4=numericExpression();
 16504   
 
 16505  36 
                     state._fsp--;
 16506   
 
 16507  36 
                     stream_numericExpression.add(n4.getTree());
 16508   
 
 16509   
                     // AST REWRITE
 16510   
                     // elements: n4, LESS, relationalExpression
 16511   
                     // token labels:
 16512   
                     // rule labels: retval, n4
 16513   
                     // token list labels:
 16514   
                     // rule list labels:
 16515   
                     // wildcard labels:
 16516  36 
                     retval.tree = root_0;
 16517  36 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16518  36 
                     RewriteRuleSubtreeStream stream_n4=new RewriteRuleSubtreeStream(adaptor,"rule n4",n4!=null?n4.tree:null);
 16519   
 
 16520  36 
                     root_0 = (Object)adaptor.nil();
 16521   
                     // 498:66: -> ^( LESS $relationalExpression $n4)
 16522   
                     {
 16523   
                         // com\\googlecode\\sparkleg\\Sparql.g:498:69: ^( LESS $relationalExpression $n4)
 16524   
                         {
 16525  36 
                         Object root_1 = (Object)adaptor.nil();
 16526  36 
                         root_1 = (Object)adaptor.becomeRoot(
 16527   
                         stream_LESS.nextNode()
 16528   
                         , root_1);
 16529   
 
 16530  36 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16531   
 
 16532  36 
                         adaptor.addChild(root_1, stream_n4.nextTree());
 16533   
 
 16534  36 
                         adaptor.addChild(root_0, root_1);
 16535   
                         }
 16536   
 
 16537   
                     }
 16538   
 
 16539   
 
 16540  36 
                     retval.tree = root_0;
 16541   
 
 16542   
                     }
 16543   
 
 16544   
 
 16545   
                     }
 16546  36 
                     break;
 16547   
                 case 4 :
 16548   
                     // com\\googlecode\\sparkleg\\Sparql.g:499:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16549   
                     {
 16550   
                     // com\\googlecode\\sparkleg\\Sparql.g:499:39: ( GREATER n5= numericExpression -> ^( GREATER $relationalExpression $n5) )
 16551   
                     // com\\googlecode\\sparkleg\\Sparql.g:499:40: GREATER n5= numericExpression
 16552   
                     {
 16553  36 
                     GREATER357=(Token)match(input,GREATER,FOLLOW_GREATER_in_relationalExpression4224);
 16554  36 
                     stream_GREATER.add(GREATER357);
 16555   
 
 16556   
 
 16557  36 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4228);
 16558  36 
                     n5=numericExpression();
 16559   
 
 16560  36 
                     state._fsp--;
 16561   
 
 16562  36 
                     stream_numericExpression.add(n5.getTree());
 16563   
 
 16564   
                     // AST REWRITE
 16565   
                     // elements: n5, relationalExpression, GREATER
 16566   
                     // token labels:
 16567   
                     // rule labels: retval, n5
 16568   
                     // token list labels:
 16569   
                     // rule list labels:
 16570   
                     // wildcard labels:
 16571  36 
                     retval.tree = root_0;
 16572  36 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16573  36 
                     RewriteRuleSubtreeStream stream_n5=new RewriteRuleSubtreeStream(adaptor,"rule n5",n5!=null?n5.tree:null);
 16574   
 
 16575  36 
                     root_0 = (Object)adaptor.nil();
 16576   
                     // 499:69: -> ^( GREATER $relationalExpression $n5)
 16577   
                     {
 16578   
                         // com\\googlecode\\sparkleg\\Sparql.g:499:72: ^( GREATER $relationalExpression $n5)
 16579   
                         {
 16580  36 
                         Object root_1 = (Object)adaptor.nil();
 16581  36 
                         root_1 = (Object)adaptor.becomeRoot(
 16582   
                         stream_GREATER.nextNode()
 16583   
                         , root_1);
 16584   
 
 16585  36 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16586   
 
 16587  36 
                         adaptor.addChild(root_1, stream_n5.nextTree());
 16588   
 
 16589  36 
                         adaptor.addChild(root_0, root_1);
 16590   
                         }
 16591   
 
 16592   
                     }
 16593   
 
 16594   
 
 16595  36 
                     retval.tree = root_0;
 16596   
 
 16597   
                     }
 16598   
 
 16599   
 
 16600   
                     }
 16601  36 
                     break;
 16602   
                 case 5 :
 16603   
                     // com\\googlecode\\sparkleg\\Sparql.g:500:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16604   
                     {
 16605   
                     // com\\googlecode\\sparkleg\\Sparql.g:500:39: ( LESS_EQUAL n6= numericExpression -> ^( LESS_EQUAL $relationalExpression $n6) )
 16606   
                     // com\\googlecode\\sparkleg\\Sparql.g:500:40: LESS_EQUAL n6= numericExpression
 16607   
                     {
 16608  4 
                     LESS_EQUAL358=(Token)match(input,LESS_EQUAL,FOLLOW_LESS_EQUAL_in_relationalExpression4282);
 16609  4 
                     stream_LESS_EQUAL.add(LESS_EQUAL358);
 16610   
 
 16611   
 
 16612  4 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4286);
 16613  4 
                     n6=numericExpression();
 16614   
 
 16615  4 
                     state._fsp--;
 16616   
 
 16617  4 
                     stream_numericExpression.add(n6.getTree());
 16618   
 
 16619   
                     // AST REWRITE
 16620   
                     // elements: n6, relationalExpression, LESS_EQUAL
 16621   
                     // token labels:
 16622   
                     // rule labels: retval, n6
 16623   
                     // token list labels:
 16624   
                     // rule list labels:
 16625   
                     // wildcard labels:
 16626  4 
                     retval.tree = root_0;
 16627  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16628  4 
                     RewriteRuleSubtreeStream stream_n6=new RewriteRuleSubtreeStream(adaptor,"rule n6",n6!=null?n6.tree:null);
 16629   
 
 16630  4 
                     root_0 = (Object)adaptor.nil();
 16631   
                     // 500:72: -> ^( LESS_EQUAL $relationalExpression $n6)
 16632   
                     {
 16633   
                         // com\\googlecode\\sparkleg\\Sparql.g:500:75: ^( LESS_EQUAL $relationalExpression $n6)
 16634   
                         {
 16635  4 
                         Object root_1 = (Object)adaptor.nil();
 16636  4 
                         root_1 = (Object)adaptor.becomeRoot(
 16637   
                         stream_LESS_EQUAL.nextNode()
 16638   
                         , root_1);
 16639   
 
 16640  4 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16641   
 
 16642  4 
                         adaptor.addChild(root_1, stream_n6.nextTree());
 16643   
 
 16644  4 
                         adaptor.addChild(root_0, root_1);
 16645   
                         }
 16646   
 
 16647   
                     }
 16648   
 
 16649   
 
 16650  4 
                     retval.tree = root_0;
 16651   
 
 16652   
                     }
 16653   
 
 16654   
 
 16655   
                     }
 16656  4 
                     break;
 16657   
                 case 6 :
 16658   
                     // com\\googlecode\\sparkleg\\Sparql.g:501:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16659   
                     {
 16660   
                     // com\\googlecode\\sparkleg\\Sparql.g:501:39: ( GREATER_EQUAL n7= numericExpression -> ^( GREATER_EQUAL $relationalExpression $n7) )
 16661   
                     // com\\googlecode\\sparkleg\\Sparql.g:501:40: GREATER_EQUAL n7= numericExpression
 16662   
                     {
 16663  6 
                     GREATER_EQUAL359=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_relationalExpression4340);
 16664  6 
                     stream_GREATER_EQUAL.add(GREATER_EQUAL359);
 16665   
 
 16666   
 
 16667  6 
                     pushFollow(FOLLOW_numericExpression_in_relationalExpression4344);
 16668  6 
                     n7=numericExpression();
 16669   
 
 16670  6 
                     state._fsp--;
 16671   
 
 16672  6 
                     stream_numericExpression.add(n7.getTree());
 16673   
 
 16674   
                     // AST REWRITE
 16675   
                     // elements: n7, relationalExpression, GREATER_EQUAL
 16676   
                     // token labels:
 16677   
                     // rule labels: retval, n7
 16678   
                     // token list labels:
 16679   
                     // rule list labels:
 16680   
                     // wildcard labels:
 16681  6 
                     retval.tree = root_0;
 16682  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16683  6 
                     RewriteRuleSubtreeStream stream_n7=new RewriteRuleSubtreeStream(adaptor,"rule n7",n7!=null?n7.tree:null);
 16684   
 
 16685  6 
                     root_0 = (Object)adaptor.nil();
 16686   
                     // 501:75: -> ^( GREATER_EQUAL $relationalExpression $n7)
 16687   
                     {
 16688   
                         // com\\googlecode\\sparkleg\\Sparql.g:501:78: ^( GREATER_EQUAL $relationalExpression $n7)
 16689   
                         {
 16690  6 
                         Object root_1 = (Object)adaptor.nil();
 16691  6 
                         root_1 = (Object)adaptor.becomeRoot(
 16692   
                         stream_GREATER_EQUAL.nextNode()
 16693   
                         , root_1);
 16694   
 
 16695  6 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16696   
 
 16697  6 
                         adaptor.addChild(root_1, stream_n7.nextTree());
 16698   
 
 16699  6 
                         adaptor.addChild(root_0, root_1);
 16700   
                         }
 16701   
 
 16702   
                     }
 16703   
 
 16704   
 
 16705  6 
                     retval.tree = root_0;
 16706   
 
 16707   
                     }
 16708   
 
 16709   
 
 16710   
                     }
 16711  6 
                     break;
 16712   
                 case 7 :
 16713   
                     // com\\googlecode\\sparkleg\\Sparql.g:502:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16714   
                     {
 16715   
                     // com\\googlecode\\sparkleg\\Sparql.g:502:39: ( IN l2= expressionList -> ^( IN $relationalExpression $l2) )
 16716   
                     // com\\googlecode\\sparkleg\\Sparql.g:502:40: IN l2= expressionList
 16717   
                     {
 16718  4 
                     IN360=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4400);
 16719  4 
                     stream_IN.add(IN360);
 16720   
 
 16721   
 
 16722  4 
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4404);
 16723  4 
                     l2=expressionList();
 16724   
 
 16725  4 
                     state._fsp--;
 16726   
 
 16727  4 
                     stream_expressionList.add(l2.getTree());
 16728   
 
 16729   
                     // AST REWRITE
 16730   
                     // elements: IN, relationalExpression, l2
 16731   
                     // token labels:
 16732   
                     // rule labels: retval, l2
 16733   
                     // token list labels:
 16734   
                     // rule list labels:
 16735   
                     // wildcard labels:
 16736  4 
                     retval.tree = root_0;
 16737  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16738  4 
                     RewriteRuleSubtreeStream stream_l2=new RewriteRuleSubtreeStream(adaptor,"rule l2",l2!=null?l2.tree:null);
 16739   
 
 16740  4 
                     root_0 = (Object)adaptor.nil();
 16741   
                     // 502:61: -> ^( IN $relationalExpression $l2)
 16742   
                     {
 16743   
                         // com\\googlecode\\sparkleg\\Sparql.g:502:64: ^( IN $relationalExpression $l2)
 16744   
                         {
 16745  4 
                         Object root_1 = (Object)adaptor.nil();
 16746  4 
                         root_1 = (Object)adaptor.becomeRoot(
 16747   
                         stream_IN.nextNode()
 16748   
                         , root_1);
 16749   
 
 16750  4 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16751   
 
 16752  4 
                         adaptor.addChild(root_1, stream_l2.nextTree());
 16753   
 
 16754  4 
                         adaptor.addChild(root_0, root_1);
 16755   
                         }
 16756   
 
 16757   
                     }
 16758   
 
 16759   
 
 16760  4 
                     retval.tree = root_0;
 16761   
 
 16762   
                     }
 16763   
 
 16764   
 
 16765   
                     }
 16766  4 
                     break;
 16767   
                 case 8 :
 16768   
                     // com\\googlecode\\sparkleg\\Sparql.g:503:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16769   
                     {
 16770   
                     // com\\googlecode\\sparkleg\\Sparql.g:503:39: ( NOT IN l3= expressionList -> ^( NOT IN $relationalExpression $l3) )
 16771   
                     // com\\googlecode\\sparkleg\\Sparql.g:503:40: NOT IN l3= expressionList
 16772   
                     {
 16773  4 
                     NOT361=(Token)match(input,NOT,FOLLOW_NOT_in_relationalExpression4458);
 16774  4 
                     stream_NOT.add(NOT361);
 16775   
 
 16776   
 
 16777  4 
                     IN362=(Token)match(input,IN,FOLLOW_IN_in_relationalExpression4460);
 16778  4 
                     stream_IN.add(IN362);
 16779   
 
 16780   
 
 16781  4 
                     pushFollow(FOLLOW_expressionList_in_relationalExpression4464);
 16782  4 
                     l3=expressionList();
 16783   
 
 16784  4 
                     state._fsp--;
 16785   
 
 16786  4 
                     stream_expressionList.add(l3.getTree());
 16787   
 
 16788   
                     // AST REWRITE
 16789   
                     // elements: IN, NOT, l3, relationalExpression
 16790   
                     // token labels:
 16791   
                     // rule labels: retval, l3
 16792   
                     // token list labels:
 16793   
                     // rule list labels:
 16794   
                     // wildcard labels:
 16795  4 
                     retval.tree = root_0;
 16796  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16797  4 
                     RewriteRuleSubtreeStream stream_l3=new RewriteRuleSubtreeStream(adaptor,"rule l3",l3!=null?l3.tree:null);
 16798   
 
 16799  4 
                     root_0 = (Object)adaptor.nil();
 16800   
                     // 503:65: -> ^( NOT IN $relationalExpression $l3)
 16801   
                     {
 16802   
                         // com\\googlecode\\sparkleg\\Sparql.g:503:68: ^( NOT IN $relationalExpression $l3)
 16803   
                         {
 16804  4 
                         Object root_1 = (Object)adaptor.nil();
 16805  4 
                         root_1 = (Object)adaptor.becomeRoot(
 16806   
                         stream_NOT.nextNode()
 16807   
                         , root_1);
 16808   
 
 16809  4 
                         adaptor.addChild(root_1,
 16810   
                         stream_IN.nextNode()
 16811   
                         );
 16812   
 
 16813  4 
                         adaptor.addChild(root_1, stream_retval.nextTree());
 16814   
 
 16815  4 
                         adaptor.addChild(root_1, stream_l3.nextTree());
 16816   
 
 16817  4 
                         adaptor.addChild(root_0, root_1);
 16818   
                         }
 16819   
 
 16820   
                     }
 16821   
 
 16822   
 
 16823  4 
                     retval.tree = root_0;
 16824   
 
 16825   
                     }
 16826   
 
 16827   
 
 16828   
                     }
 16829   
                     break;
 16830   
 
 16831   
             }
 16832   
 
 16833   
 
 16834   
             }
 16835   
 
 16836  1736 
             retval.stop = input.LT(-1);
 16837   
 
 16838   
 
 16839  1736 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16840  1736 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16841   
 
 16842   
         }
 16843  0 
         catch (RecognitionException re) {
 16844  0 
             reportError(re);
 16845  0 
             recover(input,re);
 16846  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16847   
 
 16848   
         }
 16849   
 
 16850  0 
         finally {
 16851   
                 // do for sure before leaving
 16852  1736 
         }
 16853  1736 
         return retval;
 16854   
     }
 16855   
     // $ANTLR end "relationalExpression"
 16856   
 
 16857   
 
 16858  2150 
     public static class numericExpression_return extends ParserRuleReturnScope {
 16859   
         Object tree;
 16860  2150 
         public Object getTree() { return tree; }
 16861   
     };
 16862   
 
 16863   
 
 16864   
     // $ANTLR start "numericExpression"
 16865   
     // com\\googlecode\\sparkleg\\Sparql.g:506:1: numericExpression : additiveExpression ;
 16866   
     public final SparqlParser.numericExpression_return numericExpression() throws RecognitionException {
 16867  2150 
         SparqlParser.numericExpression_return retval = new SparqlParser.numericExpression_return();
 16868  2150 
         retval.start = input.LT(1);
 16869   
 
 16870   
 
 16871  2150 
         Object root_0 = null;
 16872   
 
 16873  2150 
         SparqlParser.additiveExpression_return additiveExpression363 =null;
 16874   
 
 16875   
 
 16876   
 
 16877   
         try {
 16878   
             // com\\googlecode\\sparkleg\\Sparql.g:507:5: ( additiveExpression )
 16879   
             // com\\googlecode\\sparkleg\\Sparql.g:507:7: additiveExpression
 16880   
             {
 16881  2150 
             root_0 = (Object)adaptor.nil();
 16882   
 
 16883   
 
 16884  2150 
             pushFollow(FOLLOW_additiveExpression_in_numericExpression4498);
 16885  2150 
             additiveExpression363=additiveExpression();
 16886   
 
 16887  2150 
             state._fsp--;
 16888   
 
 16889  2150 
             adaptor.addChild(root_0, additiveExpression363.getTree());
 16890   
 
 16891   
             }
 16892   
 
 16893  2150 
             retval.stop = input.LT(-1);
 16894   
 
 16895   
 
 16896  2150 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 16897  2150 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 16898   
 
 16899   
         }
 16900  0 
         catch (RecognitionException re) {
 16901  0 
             reportError(re);
 16902  0 
             recover(input,re);
 16903  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 16904   
 
 16905   
         }
 16906   
 
 16907  0 
         finally {
 16908   
                 // do for sure before leaving
 16909  2150 
         }
 16910  2150 
         return retval;
 16911   
     }
 16912   
     // $ANTLR end "numericExpression"
 16913   
 
 16914   
 
 16915  2150 
     public static class additiveExpression_return extends ParserRuleReturnScope {
 16916   
         Object tree;
 16917  2150 
         public Object getTree() { return tree; }
 16918   
     };
 16919   
 
 16920   
 
 16921   
     // $ANTLR start "additiveExpression"
 16922   
     // com\\googlecode\\sparkleg\\Sparql.g:510:1: additiveExpression : (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* ;
 16923   
     public final SparqlParser.additiveExpression_return additiveExpression() throws RecognitionException {
 16924  2150 
         SparqlParser.additiveExpression_return retval = new SparqlParser.additiveExpression_return();
 16925  2150 
         retval.start = input.LT(1);
 16926   
 
 16927   
 
 16928  2150 
         Object root_0 = null;
 16929   
 
 16930  2150 
         Token ASTERISK365=null;
 16931  2150 
         Token DIVIDE366=null;
 16932  2150 
         SparqlParser.multiplicativeExpression_return m1 =null;
 16933   
 
 16934  2150 
         SparqlParser.multiplicativeExpression_return m2 =null;
 16935   
 
 16936  2150 
         SparqlParser.numericLiteralPositive_return n1 =null;
 16937   
 
 16938  2150 
         SparqlParser.numericLiteralNegative_return n2 =null;
 16939   
 
 16940  2150 
         SparqlParser.unaryExpression_return u2 =null;
 16941   
 
 16942  2150 
         SparqlParser.additiveOperator_return additiveOperator364 =null;
 16943   
 
 16944   
 
 16945  2150 
         Object ASTERISK365_tree=null;
 16946  2150 
         Object DIVIDE366_tree=null;
 16947  2150 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 16948  2150 
         RewriteRuleTokenStream stream_DIVIDE=new RewriteRuleTokenStream(adaptor,"token DIVIDE");
 16949  2150 
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 16950  2150 
         RewriteRuleSubtreeStream stream_numericLiteralNegative=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralNegative");
 16951  2150 
         RewriteRuleSubtreeStream stream_numericLiteralPositive=new RewriteRuleSubtreeStream(adaptor,"rule numericLiteralPositive");
 16952  2150 
         RewriteRuleSubtreeStream stream_additiveOperator=new RewriteRuleSubtreeStream(adaptor,"rule additiveOperator");
 16953  2150 
         RewriteRuleSubtreeStream stream_multiplicativeExpression=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeExpression");
 16954   
         try {
 16955   
             // com\\googlecode\\sparkleg\\Sparql.g:511:5: ( (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )* )
 16956   
             // com\\googlecode\\sparkleg\\Sparql.g:511:7: (m1= multiplicativeExpression -> $m1) ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16957   
             {
 16958   
             // com\\googlecode\\sparkleg\\Sparql.g:511:7: (m1= multiplicativeExpression -> $m1)
 16959   
             // com\\googlecode\\sparkleg\\Sparql.g:511:8: m1= multiplicativeExpression
 16960   
             {
 16961  2150 
             pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4518);
 16962  2150 
             m1=multiplicativeExpression();
 16963   
 
 16964  2150 
             state._fsp--;
 16965   
 
 16966  2150 
             stream_multiplicativeExpression.add(m1.getTree());
 16967   
 
 16968   
             // AST REWRITE
 16969   
             // elements: m1
 16970   
             // token labels:
 16971   
             // rule labels: retval, m1
 16972   
             // token list labels:
 16973   
             // rule list labels:
 16974   
             // wildcard labels:
 16975  2150 
             retval.tree = root_0;
 16976  2150 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 16977  2150 
             RewriteRuleSubtreeStream stream_m1=new RewriteRuleSubtreeStream(adaptor,"rule m1",m1!=null?m1.tree:null);
 16978   
 
 16979  2150 
             root_0 = (Object)adaptor.nil();
 16980   
             // 511:36: -> $m1
 16981   
             {
 16982  2150 
                 adaptor.addChild(root_0, stream_m1.nextTree());
 16983   
 
 16984   
             }
 16985   
 
 16986   
 
 16987  2150 
             retval.tree = root_0;
 16988   
 
 16989   
             }
 16990   
 
 16991   
 
 16992   
             // com\\googlecode\\sparkleg\\Sparql.g:511:44: ( ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) ) | (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )? )*
 16993   
             loop122:
 16994   
             do {
 16995  2296 
                 int alt122=3;
 16996  2296 
                 switch ( input.LA(1) ) {
 16997   
                 case MINUS:
 16998   
                 case PLUS:
 16999   
                     {
 17000  126 
                     alt122=1;
 17001   
                     }
 17002  126 
                     break;
 17003   
                 case DECIMAL_NEGATIVE:
 17004   
                 case DECIMAL_POSITIVE:
 17005   
                 case DOUBLE_NEGATIVE:
 17006   
                 case DOUBLE_POSITIVE:
 17007   
                 case INTEGER_NEGATIVE:
 17008   
                 case INTEGER_POSITIVE:
 17009   
                     {
 17010  20 
                     alt122=2;
 17011   
                     }
 17012   
                     break;
 17013   
 
 17014   
                 }
 17015   
 
 17016  2296 
                 switch (alt122) {
 17017   
                     case 1 :
 17018   
                         // com\\googlecode\\sparkleg\\Sparql.g:511:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17019   
                         {
 17020   
                         // com\\googlecode\\sparkleg\\Sparql.g:511:45: ( additiveOperator m2= multiplicativeExpression -> ^( additiveOperator $additiveExpression $m2) )
 17021   
                         // com\\googlecode\\sparkleg\\Sparql.g:511:46: additiveOperator m2= multiplicativeExpression
 17022   
                         {
 17023  126 
                         pushFollow(FOLLOW_additiveOperator_in_additiveExpression4528);
 17024  126 
                         additiveOperator364=additiveOperator();
 17025   
 
 17026  126 
                         state._fsp--;
 17027   
 
 17028  126 
                         stream_additiveOperator.add(additiveOperator364.getTree());
 17029   
 
 17030  126 
                         pushFollow(FOLLOW_multiplicativeExpression_in_additiveExpression4532);
 17031  126 
                         m2=multiplicativeExpression();
 17032   
 
 17033  126 
                         state._fsp--;
 17034   
 
 17035  126 
                         stream_multiplicativeExpression.add(m2.getTree());
 17036   
 
 17037   
                         // AST REWRITE
 17038   
                         // elements: m2, additiveOperator, additiveExpression
 17039   
                         // token labels:
 17040   
                         // rule labels: retval, m2
 17041   
                         // token list labels:
 17042   
                         // rule list labels:
 17043   
                         // wildcard labels:
 17044  126 
                         retval.tree = root_0;
 17045  126 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17046  126 
                         RewriteRuleSubtreeStream stream_m2=new RewriteRuleSubtreeStream(adaptor,"rule m2",m2!=null?m2.tree:null);
 17047   
 
 17048  126 
                         root_0 = (Object)adaptor.nil();
 17049   
                         // 511:91: -> ^( additiveOperator $additiveExpression $m2)
 17050   
                         {
 17051   
                             // com\\googlecode\\sparkleg\\Sparql.g:511:94: ^( additiveOperator $additiveExpression $m2)
 17052   
                             {
 17053  126 
                             Object root_1 = (Object)adaptor.nil();
 17054  126 
                             root_1 = (Object)adaptor.becomeRoot(stream_additiveOperator.nextNode(), root_1);
 17055   
 
 17056  126 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17057   
 
 17058  126 
                             adaptor.addChild(root_1, stream_m2.nextTree());
 17059   
 
 17060  126 
                             adaptor.addChild(root_0, root_1);
 17061   
                             }
 17062   
 
 17063   
                         }
 17064   
 
 17065   
 
 17066  126 
                         retval.tree = root_0;
 17067   
 
 17068   
                         }
 17069   
 
 17070   
 
 17071   
                         }
 17072  126 
                         break;
 17073   
                     case 2 :
 17074   
                         // com\\googlecode\\sparkleg\\Sparql.g:512:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) ) ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 17075   
                         {
 17076   
                         // com\\googlecode\\sparkleg\\Sparql.g:512:48: (n1= numericLiteralPositive -> ^( PLUS $additiveExpression $n1) |n2= numericLiteralNegative -> ^( PLUS $additiveExpression $n2) )
 17077  20 
                         int alt120=2;
 17078  20 
                         switch ( input.LA(1) ) {
 17079   
                         case DECIMAL_POSITIVE:
 17080   
                         case DOUBLE_POSITIVE:
 17081   
                         case INTEGER_POSITIVE:
 17082   
                             {
 17083  20 
                             alt120=1;
 17084   
                             }
 17085  20 
                             break;
 17086   
                         case DECIMAL_NEGATIVE:
 17087   
                         case DOUBLE_NEGATIVE:
 17088   
                         case INTEGER_NEGATIVE:
 17089   
                             {
 17090  0 
                             alt120=2;
 17091   
                             }
 17092  0 
                             break;
 17093   
                         default:
 17094  0 
                             NoViableAltException nvae =
 17095   
                                 new NoViableAltException("", 120, 0, input);
 17096   
 
 17097  0 
                             throw nvae;
 17098   
 
 17099   
                         }
 17100   
 
 17101  20 
                         switch (alt120) {
 17102   
                             case 1 :
 17103   
                                 // com\\googlecode\\sparkleg\\Sparql.g:512:49: n1= numericLiteralPositive
 17104   
                                 {
 17105  20 
                                 pushFollow(FOLLOW_numericLiteralPositive_in_additiveExpression4599);
 17106  20 
                                 n1=numericLiteralPositive();
 17107   
 
 17108  20 
                                 state._fsp--;
 17109   
 
 17110  20 
                                 stream_numericLiteralPositive.add(n1.getTree());
 17111   
 
 17112   
                                 // AST REWRITE
 17113   
                                 // elements: n1, additiveExpression
 17114   
                                 // token labels:
 17115   
                                 // rule labels: n1, retval
 17116   
                                 // token list labels:
 17117   
                                 // rule list labels:
 17118   
                                 // wildcard labels:
 17119  20 
                                 retval.tree = root_0;
 17120  20 
                                 RewriteRuleSubtreeStream stream_n1=new RewriteRuleSubtreeStream(adaptor,"rule n1",n1!=null?n1.tree:null);
 17121  20 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17122   
 
 17123  20 
                                 root_0 = (Object)adaptor.nil();
 17124   
                                 // 512:75: -> ^( PLUS $additiveExpression $n1)
 17125   
                                 {
 17126   
                                     // com\\googlecode\\sparkleg\\Sparql.g:512:78: ^( PLUS $additiveExpression $n1)
 17127   
                                     {
 17128  20 
                                     Object root_1 = (Object)adaptor.nil();
 17129  20 
                                     root_1 = (Object)adaptor.becomeRoot(
 17130   
                                     (Object)adaptor.create(PLUS, "PLUS")
 17131   
                                     , root_1);
 17132   
 
 17133  20 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17134   
 
 17135  20 
                                     adaptor.addChild(root_1, stream_n1.nextTree());
 17136   
 
 17137  20 
                                     adaptor.addChild(root_0, root_1);
 17138   
                                     }
 17139   
 
 17140   
                                 }
 17141   
 
 17142   
 
 17143  20 
                                 retval.tree = root_0;
 17144   
 
 17145   
                                 }
 17146  20 
                                 break;
 17147   
                             case 2 :
 17148   
                                 // com\\googlecode\\sparkleg\\Sparql.g:512:112: n2= numericLiteralNegative
 17149   
                                 {
 17150  0 
                                 pushFollow(FOLLOW_numericLiteralNegative_in_additiveExpression4617);
 17151  0 
                                 n2=numericLiteralNegative();
 17152   
 
 17153  0 
                                 state._fsp--;
 17154   
 
 17155  0 
                                 stream_numericLiteralNegative.add(n2.getTree());
 17156   
 
 17157   
                                 // AST REWRITE
 17158   
                                 // elements: n2, additiveExpression
 17159   
                                 // token labels:
 17160   
                                 // rule labels: retval, n2
 17161   
                                 // token list labels:
 17162   
                                 // rule list labels:
 17163   
                                 // wildcard labels:
 17164  0 
                                 retval.tree = root_0;
 17165  0 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17166  0 
                                 RewriteRuleSubtreeStream stream_n2=new RewriteRuleSubtreeStream(adaptor,"rule n2",n2!=null?n2.tree:null);
 17167   
 
 17168  0 
                                 root_0 = (Object)adaptor.nil();
 17169   
                                 // 512:138: -> ^( PLUS $additiveExpression $n2)
 17170   
                                 {
 17171   
                                     // com\\googlecode\\sparkleg\\Sparql.g:512:141: ^( PLUS $additiveExpression $n2)
 17172   
                                     {
 17173  0 
                                     Object root_1 = (Object)adaptor.nil();
 17174  0 
                                     root_1 = (Object)adaptor.becomeRoot(
 17175   
                                     (Object)adaptor.create(PLUS, "PLUS")
 17176   
                                     , root_1);
 17177   
 
 17178  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17179   
 
 17180  0 
                                     adaptor.addChild(root_1, stream_n2.nextTree());
 17181   
 
 17182  0 
                                     adaptor.addChild(root_0, root_1);
 17183   
                                     }
 17184   
 
 17185   
                                 }
 17186   
 
 17187   
 
 17188  0 
                                 retval.tree = root_0;
 17189   
 
 17190   
                                 }
 17191   
                                 break;
 17192   
 
 17193   
                         }
 17194   
 
 17195   
 
 17196   
                         // com\\googlecode\\sparkleg\\Sparql.g:513:46: ( ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) ) | ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) ) )?
 17197  20 
                         int alt121=3;
 17198  20 
                         switch ( input.LA(1) ) {
 17199   
                             case ASTERISK:
 17200   
                                 {
 17201  0 
                                 alt121=1;
 17202   
                                 }
 17203  0 
                                 break;
 17204   
                             case DIVIDE:
 17205   
                                 {
 17206  0 
                                 alt121=2;
 17207   
                                 }
 17208   
                                 break;
 17209   
                         }
 17210   
 
 17211  20 
                         switch (alt121) {
 17212   
                             case 1 :
 17213   
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17214   
                                 {
 17215   
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:47: ( ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) ) )
 17216   
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17217   
                                 {
 17218   
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:48: ( ASTERISK u2= unaryExpression -> ^( ASTERISK $additiveExpression $u2) )
 17219   
                                 // com\\googlecode\\sparkleg\\Sparql.g:513:49: ASTERISK u2= unaryExpression
 17220   
                                 {
 17221  0 
                                 ASTERISK365=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_additiveExpression4681);
 17222  0 
                                 stream_ASTERISK.add(ASTERISK365);
 17223   
 
 17224   
 
 17225  0 
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4685);
 17226  0 
                                 u2=unaryExpression();
 17227   
 
 17228  0 
                                 state._fsp--;
 17229   
 
 17230  0 
                                 stream_unaryExpression.add(u2.getTree());
 17231   
 
 17232   
                                 // AST REWRITE
 17233   
                                 // elements: u2, additiveExpression, ASTERISK
 17234   
                                 // token labels:
 17235   
                                 // rule labels: retval, u2
 17236   
                                 // token list labels:
 17237   
                                 // rule list labels:
 17238   
                                 // wildcard labels:
 17239  0 
                                 retval.tree = root_0;
 17240  0 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17241  0 
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17242   
 
 17243  0 
                                 root_0 = (Object)adaptor.nil();
 17244   
                                 // 513:77: -> ^( ASTERISK $additiveExpression $u2)
 17245   
                                 {
 17246   
                                     // com\\googlecode\\sparkleg\\Sparql.g:513:80: ^( ASTERISK $additiveExpression $u2)
 17247   
                                     {
 17248  0 
                                     Object root_1 = (Object)adaptor.nil();
 17249  0 
                                     root_1 = (Object)adaptor.becomeRoot(
 17250   
                                     stream_ASTERISK.nextNode()
 17251   
                                     , root_1);
 17252   
 
 17253  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17254   
 
 17255  0 
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17256   
 
 17257  0 
                                     adaptor.addChild(root_0, root_1);
 17258   
                                     }
 17259   
 
 17260   
                                 }
 17261   
 
 17262   
 
 17263  0 
                                 retval.tree = root_0;
 17264   
 
 17265   
                                 }
 17266   
 
 17267   
 
 17268   
                                 }
 17269   
 
 17270   
 
 17271   
                                 }
 17272  0 
                                 break;
 17273   
                             case 2 :
 17274   
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17275   
                                 {
 17276   
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:48: ( ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) ) )
 17277   
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17278   
                                 {
 17279   
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:49: ( DIVIDE u2= unaryExpression -> ^( DIVIDE $additiveExpression $u2) )
 17280   
                                 // com\\googlecode\\sparkleg\\Sparql.g:514:50: DIVIDE u2= unaryExpression
 17281   
                                 {
 17282  0 
                                 DIVIDE366=(Token)match(input,DIVIDE,FOLLOW_DIVIDE_in_additiveExpression4751);
 17283  0 
                                 stream_DIVIDE.add(DIVIDE366);
 17284   
 
 17285   
 
 17286  0 
                                 pushFollow(FOLLOW_unaryExpression_in_additiveExpression4755);
 17287  0 
                                 u2=unaryExpression();
 17288   
 
 17289  0 
                                 state._fsp--;
 17290   
 
 17291  0 
                                 stream_unaryExpression.add(u2.getTree());
 17292   
 
 17293   
                                 // AST REWRITE
 17294   
                                 // elements: u2, additiveExpression, DIVIDE
 17295   
                                 // token labels:
 17296   
                                 // rule labels: retval, u2
 17297   
                                 // token list labels:
 17298   
                                 // rule list labels:
 17299   
                                 // wildcard labels:
 17300  0 
                                 retval.tree = root_0;
 17301  0 
                                 RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17302  0 
                                 RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17303   
 
 17304  0 
                                 root_0 = (Object)adaptor.nil();
 17305   
                                 // 514:76: -> ^( DIVIDE $additiveExpression $u2)
 17306   
                                 {
 17307   
                                     // com\\googlecode\\sparkleg\\Sparql.g:514:79: ^( DIVIDE $additiveExpression $u2)
 17308   
                                     {
 17309  0 
                                     Object root_1 = (Object)adaptor.nil();
 17310  0 
                                     root_1 = (Object)adaptor.becomeRoot(
 17311   
                                     stream_DIVIDE.nextNode()
 17312   
                                     , root_1);
 17313   
 
 17314  0 
                                     adaptor.addChild(root_1, stream_retval.nextTree());
 17315   
 
 17316  0 
                                     adaptor.addChild(root_1, stream_u2.nextTree());
 17317   
 
 17318  0 
                                     adaptor.addChild(root_0, root_1);
 17319   
                                     }
 17320   
 
 17321   
                                 }
 17322   
 
 17323   
 
 17324  0 
                                 retval.tree = root_0;
 17325   
 
 17326   
                                 }
 17327   
 
 17328   
 
 17329   
                                 }
 17330   
 
 17331   
 
 17332   
                                 }
 17333   
                                 break;
 17334   
 
 17335   
                         }
 17336   
 
 17337   
 
 17338   
                         }
 17339  20 
                         break;
 17340   
 
 17341   
                     default :
 17342  2150 
                         break loop122;
 17343   
                 }
 17344  146 
             } while (true);
 17345   
 
 17346   
 
 17347   
             }
 17348   
 
 17349  2150 
             retval.stop = input.LT(-1);
 17350   
 
 17351   
 
 17352  2150 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17353  2150 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17354   
 
 17355   
         }
 17356  0 
         catch (RecognitionException re) {
 17357  0 
             reportError(re);
 17358  0 
             recover(input,re);
 17359  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17360   
 
 17361   
         }
 17362   
 
 17363  0 
         finally {
 17364   
                 // do for sure before leaving
 17365  2150 
         }
 17366  2150 
         return retval;
 17367   
     }
 17368   
     // $ANTLR end "additiveExpression"
 17369   
 
 17370   
 
 17371  126 
     public static class additiveOperator_return extends ParserRuleReturnScope {
 17372   
         Object tree;
 17373  126 
         public Object getTree() { return tree; }
 17374   
     };
 17375   
 
 17376   
 
 17377   
     // $ANTLR start "additiveOperator"
 17378   
     // com\\googlecode\\sparkleg\\Sparql.g:517:1: additiveOperator : ( PLUS | MINUS );
 17379   
     public final SparqlParser.additiveOperator_return additiveOperator() throws RecognitionException {
 17380  126 
         SparqlParser.additiveOperator_return retval = new SparqlParser.additiveOperator_return();
 17381  126 
         retval.start = input.LT(1);
 17382   
 
 17383   
 
 17384  126 
         Object root_0 = null;
 17385   
 
 17386  126 
         Token set367=null;
 17387   
 
 17388  126 
         Object set367_tree=null;
 17389   
 
 17390   
         try {
 17391   
             // com\\googlecode\\sparkleg\\Sparql.g:518:5: ( PLUS | MINUS )
 17392   
             // com\\googlecode\\sparkleg\\Sparql.g:
 17393   
             {
 17394  126 
             root_0 = (Object)adaptor.nil();
 17395   
 
 17396   
 
 17397  126 
             set367=(Token)input.LT(1);
 17398   
 
 17399  126 
             if ( input.LA(1)==MINUS||input.LA(1)==PLUS ) {
 17400  126 
                 input.consume();
 17401  126 
                 adaptor.addChild(root_0,
 17402   
                 (Object)adaptor.create(set367)
 17403   
                 );
 17404  126 
                 state.errorRecovery=false;
 17405   
             }
 17406   
             else {
 17407  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17408  0 
                 throw mse;
 17409   
             }
 17410   
 
 17411   
 
 17412   
             }
 17413   
 
 17414  126 
             retval.stop = input.LT(-1);
 17415   
 
 17416   
 
 17417  126 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17418  126 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17419   
 
 17420   
         }
 17421  0 
         catch (RecognitionException re) {
 17422  0 
             reportError(re);
 17423  0 
             recover(input,re);
 17424  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17425   
 
 17426   
         }
 17427   
 
 17428  0 
         finally {
 17429   
                 // do for sure before leaving
 17430  126 
         }
 17431  126 
         return retval;
 17432   
     }
 17433   
     // $ANTLR end "additiveOperator"
 17434   
 
 17435   
 
 17436  2276 
     public static class multiplicativeExpression_return extends ParserRuleReturnScope {
 17437   
         Object tree;
 17438  2276 
         public Object getTree() { return tree; }
 17439   
     };
 17440   
 
 17441   
 
 17442   
     // $ANTLR start "multiplicativeExpression"
 17443   
     // com\\googlecode\\sparkleg\\Sparql.g:521:1: multiplicativeExpression : (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* ;
 17444   
     public final SparqlParser.multiplicativeExpression_return multiplicativeExpression() throws RecognitionException {
 17445  2276 
         SparqlParser.multiplicativeExpression_return retval = new SparqlParser.multiplicativeExpression_return();
 17446  2276 
         retval.start = input.LT(1);
 17447   
 
 17448   
 
 17449  2276 
         Object root_0 = null;
 17450   
 
 17451  2276 
         SparqlParser.unaryExpression_return u1 =null;
 17452   
 
 17453  2276 
         SparqlParser.unaryExpression_return u2 =null;
 17454   
 
 17455  2276 
         SparqlParser.multiplicativeOperator_return multiplicativeOperator368 =null;
 17456   
 
 17457   
 
 17458  2276 
         RewriteRuleSubtreeStream stream_multiplicativeOperator=new RewriteRuleSubtreeStream(adaptor,"rule multiplicativeOperator");
 17459  2276 
         RewriteRuleSubtreeStream stream_unaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule unaryExpression");
 17460   
         try {
 17461   
             // com\\googlecode\\sparkleg\\Sparql.g:522:5: ( (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )* )
 17462   
             // com\\googlecode\\sparkleg\\Sparql.g:522:7: (u1= unaryExpression -> $u1) ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17463   
             {
 17464   
             // com\\googlecode\\sparkleg\\Sparql.g:522:7: (u1= unaryExpression -> $u1)
 17465   
             // com\\googlecode\\sparkleg\\Sparql.g:522:8: u1= unaryExpression
 17466   
             {
 17467  2276 
             pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4821);
 17468  2276 
             u1=unaryExpression();
 17469   
 
 17470  2276 
             state._fsp--;
 17471   
 
 17472  2276 
             stream_unaryExpression.add(u1.getTree());
 17473   
 
 17474   
             // AST REWRITE
 17475   
             // elements: u1
 17476   
             // token labels:
 17477   
             // rule labels: retval, u1
 17478   
             // token list labels:
 17479   
             // rule list labels:
 17480   
             // wildcard labels:
 17481  2276 
             retval.tree = root_0;
 17482  2276 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17483  2276 
             RewriteRuleSubtreeStream stream_u1=new RewriteRuleSubtreeStream(adaptor,"rule u1",u1!=null?u1.tree:null);
 17484   
 
 17485  2276 
             root_0 = (Object)adaptor.nil();
 17486   
             // 522:27: -> $u1
 17487   
             {
 17488  2276 
                 adaptor.addChild(root_0, stream_u1.nextTree());
 17489   
 
 17490   
             }
 17491   
 
 17492   
 
 17493  2276 
             retval.tree = root_0;
 17494   
 
 17495   
             }
 17496   
 
 17497   
 
 17498   
             // com\\googlecode\\sparkleg\\Sparql.g:522:35: ( multiplicativeOperator u2= unaryExpression -> ^( multiplicativeOperator $multiplicativeExpression $u2) )*
 17499   
             loop123:
 17500   
             do {
 17501  2308 
                 int alt123=2;
 17502  2308 
                 switch ( input.LA(1) ) {
 17503   
                 case ASTERISK:
 17504   
                 case DIVIDE:
 17505   
                     {
 17506  32 
                     alt123=1;
 17507   
                     }
 17508   
                     break;
 17509   
 
 17510   
                 }
 17511   
 
 17512  2308 
                 switch (alt123) {
 17513   
                     case 1 :
 17514   
                         // com\\googlecode\\sparkleg\\Sparql.g:522:36: multiplicativeOperator u2= unaryExpression
 17515   
                         {
 17516  32 
                         pushFollow(FOLLOW_multiplicativeOperator_in_multiplicativeExpression4830);
 17517  32 
                         multiplicativeOperator368=multiplicativeOperator();
 17518   
 
 17519  32 
                         state._fsp--;
 17520   
 
 17521  32 
                         stream_multiplicativeOperator.add(multiplicativeOperator368.getTree());
 17522   
 
 17523  32 
                         pushFollow(FOLLOW_unaryExpression_in_multiplicativeExpression4834);
 17524  32 
                         u2=unaryExpression();
 17525   
 
 17526  32 
                         state._fsp--;
 17527   
 
 17528  32 
                         stream_unaryExpression.add(u2.getTree());
 17529   
 
 17530   
                         // AST REWRITE
 17531   
                         // elements: multiplicativeOperator, multiplicativeExpression, u2
 17532   
                         // token labels:
 17533   
                         // rule labels: retval, u2
 17534   
                         // token list labels:
 17535   
                         // rule list labels:
 17536   
                         // wildcard labels:
 17537  32 
                         retval.tree = root_0;
 17538  32 
                         RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17539  32 
                         RewriteRuleSubtreeStream stream_u2=new RewriteRuleSubtreeStream(adaptor,"rule u2",u2!=null?u2.tree:null);
 17540   
 
 17541  32 
                         root_0 = (Object)adaptor.nil();
 17542   
                         // 522:78: -> ^( multiplicativeOperator $multiplicativeExpression $u2)
 17543   
                         {
 17544   
                             // com\\googlecode\\sparkleg\\Sparql.g:522:81: ^( multiplicativeOperator $multiplicativeExpression $u2)
 17545   
                             {
 17546  32 
                             Object root_1 = (Object)adaptor.nil();
 17547  32 
                             root_1 = (Object)adaptor.becomeRoot(stream_multiplicativeOperator.nextNode(), root_1);
 17548   
 
 17549  32 
                             adaptor.addChild(root_1, stream_retval.nextTree());
 17550   
 
 17551  32 
                             adaptor.addChild(root_1, stream_u2.nextTree());
 17552   
 
 17553  32 
                             adaptor.addChild(root_0, root_1);
 17554   
                             }
 17555   
 
 17556   
                         }
 17557   
 
 17558   
 
 17559  32 
                         retval.tree = root_0;
 17560   
 
 17561   
                         }
 17562  32 
                         break;
 17563   
 
 17564   
                     default :
 17565  2276 
                         break loop123;
 17566   
                 }
 17567  32 
             } while (true);
 17568   
 
 17569   
 
 17570   
             }
 17571   
 
 17572  2276 
             retval.stop = input.LT(-1);
 17573   
 
 17574   
 
 17575  2276 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17576  2276 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17577   
 
 17578   
         }
 17579  0 
         catch (RecognitionException re) {
 17580  0 
             reportError(re);
 17581  0 
             recover(input,re);
 17582  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17583   
 
 17584   
         }
 17585   
 
 17586  0 
         finally {
 17587   
                 // do for sure before leaving
 17588  2276 
         }
 17589  2276 
         return retval;
 17590   
     }
 17591   
     // $ANTLR end "multiplicativeExpression"
 17592   
 
 17593   
 
 17594  32 
     public static class multiplicativeOperator_return extends ParserRuleReturnScope {
 17595   
         Object tree;
 17596  32 
         public Object getTree() { return tree; }
 17597   
     };
 17598   
 
 17599   
 
 17600   
     // $ANTLR start "multiplicativeOperator"
 17601   
     // com\\googlecode\\sparkleg\\Sparql.g:525:1: multiplicativeOperator : ( ASTERISK | DIVIDE );
 17602   
     public final SparqlParser.multiplicativeOperator_return multiplicativeOperator() throws RecognitionException {
 17603  32 
         SparqlParser.multiplicativeOperator_return retval = new SparqlParser.multiplicativeOperator_return();
 17604  32 
         retval.start = input.LT(1);
 17605   
 
 17606   
 
 17607  32 
         Object root_0 = null;
 17608   
 
 17609  32 
         Token set369=null;
 17610   
 
 17611  32 
         Object set369_tree=null;
 17612   
 
 17613   
         try {
 17614   
             // com\\googlecode\\sparkleg\\Sparql.g:526:5: ( ASTERISK | DIVIDE )
 17615   
             // com\\googlecode\\sparkleg\\Sparql.g:
 17616   
             {
 17617  32 
             root_0 = (Object)adaptor.nil();
 17618   
 
 17619   
 
 17620  32 
             set369=(Token)input.LT(1);
 17621   
 
 17622  32 
             if ( input.LA(1)==ASTERISK||input.LA(1)==DIVIDE ) {
 17623  32 
                 input.consume();
 17624  32 
                 adaptor.addChild(root_0,
 17625   
                 (Object)adaptor.create(set369)
 17626   
                 );
 17627  32 
                 state.errorRecovery=false;
 17628   
             }
 17629   
             else {
 17630  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 17631  0 
                 throw mse;
 17632   
             }
 17633   
 
 17634   
 
 17635   
             }
 17636   
 
 17637  32 
             retval.stop = input.LT(-1);
 17638   
 
 17639   
 
 17640  32 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 17641  32 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 17642   
 
 17643   
         }
 17644  0 
         catch (RecognitionException re) {
 17645  0 
             reportError(re);
 17646  0 
             recover(input,re);
 17647  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 17648   
 
 17649   
         }
 17650   
 
 17651  0 
         finally {
 17652   
                 // do for sure before leaving
 17653  32 
         }
 17654  32 
         return retval;
 17655   
     }
 17656   
     // $ANTLR end "multiplicativeOperator"
 17657   
 
 17658   
 
 17659  2308 
     public static class unaryExpression_return extends ParserRuleReturnScope {
 17660   
         Object tree;
 17661  2308 
         public Object getTree() { return tree; }
 17662   
     };
 17663   
 
 17664   
 
 17665   
     // $ANTLR start "unaryExpression"
 17666   
     // com\\googlecode\\sparkleg\\Sparql.g:529:1: unaryExpression : ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) );
 17667   
     public final SparqlParser.unaryExpression_return unaryExpression() throws RecognitionException {
 17668  2308 
         SparqlParser.unaryExpression_return retval = new SparqlParser.unaryExpression_return();
 17669  2308 
         retval.start = input.LT(1);
 17670   
 
 17671   
 
 17672  2308 
         Object root_0 = null;
 17673   
 
 17674  2308 
         Token NEGATION370=null;
 17675  2308 
         Token PLUS372=null;
 17676  2308 
         Token MINUS374=null;
 17677  2308 
         SparqlParser.primaryExpression_return primaryExpression371 =null;
 17678   
 
 17679  2308 
         SparqlParser.primaryExpression_return primaryExpression373 =null;
 17680   
 
 17681  2308 
         SparqlParser.primaryExpression_return primaryExpression375 =null;
 17682   
 
 17683  2308 
         SparqlParser.primaryExpression_return primaryExpression376 =null;
 17684   
 
 17685   
 
 17686  2308 
         Object NEGATION370_tree=null;
 17687  2308 
         Object PLUS372_tree=null;
 17688  2308 
         Object MINUS374_tree=null;
 17689  2308 
         RewriteRuleTokenStream stream_PLUS=new RewriteRuleTokenStream(adaptor,"token PLUS");
 17690  2308 
         RewriteRuleTokenStream stream_NEGATION=new RewriteRuleTokenStream(adaptor,"token NEGATION");
 17691  2308 
         RewriteRuleTokenStream stream_MINUS=new RewriteRuleTokenStream(adaptor,"token MINUS");
 17692  2308 
         RewriteRuleSubtreeStream stream_primaryExpression=new RewriteRuleSubtreeStream(adaptor,"rule primaryExpression");
 17693   
         try {
 17694   
             // com\\googlecode\\sparkleg\\Sparql.g:530:5: ( NEGATION primaryExpression -> ^( UNARY NEGATION primaryExpression ) | PLUS primaryExpression -> ^( UNARY PLUS primaryExpression ) | MINUS primaryExpression -> ^( UNARY MINUS primaryExpression ) | primaryExpression -> ^( UNARY primaryExpression ) )
 17695  2308 
             int alt124=4;
 17696  2308 
             switch ( input.LA(1) ) {
 17697   
             case NEGATION:
 17698   
                 {
 17699  38 
                 alt124=1;
 17700   
                 }
 17701  38 
                 break;
 17702   
             case PLUS:
 17703   
                 {
 17704  0 
                 alt124=2;
 17705   
                 }
 17706  0 
                 break;
 17707   
             case MINUS:
 17708   
                 {
 17709  2 
                 alt124=3;
 17710   
                 }
 17711  2 
                 break;
 17712   
             case ABS:
 17713   
             case AVG:
 17714   
             case BNODE:
 17715   
             case BOUND:
 17716   
             case CEIL:
 17717   
             case COALESCE:
 17718   
             case CONCAT:
 17719   
             case CONTAINS:
 17720   
             case COUNT:
 17721   
             case DATATYPE:
 17722   
             case DAY:
 17723   
             case DECIMAL:
 17724   
             case DECIMAL_NEGATIVE:
 17725   
             case DECIMAL_POSITIVE:
 17726   
             case DOUBLE:
 17727   
             case DOUBLE_NEGATIVE:
 17728   
             case DOUBLE_POSITIVE:
 17729   
             case ENCODE_FOR_URI:
 17730   
             case EXISTS:
 17731   
             case FALSE:
 17732   
             case FLOOR:
 17733   
             case GROUP_CONCAT:
 17734   
             case HOURS:
 17735   
             case IF:
 17736   
             case INTEGER:
 17737   
             case INTEGER_NEGATIVE:
 17738   
             case INTEGER_POSITIVE:
 17739   
             case IRI:
 17740   
             case IRI_REF:
 17741   
             case ISBLANK:
 17742   
             case ISIRI:
 17743   
             case ISLITERAL:
 17744   
             case ISNUMERIC:
 17745   
             case ISURI:
 17746   
             case LANG:
 17747   
             case LANGMATCHES:
 17748   
             case LCASE:
 17749   
             case MAX:
 17750   
             case MD5:
 17751   
             case MIN:
 17752   
             case MINUTES:
 17753   
             case MONTH:
 17754   
             case NOT:
 17755   
             case NOW:
 17756   
             case OPEN_BRACE:
 17757   
             case PNAME_LN:
 17758   
             case PNAME_NS:
 17759   
             case RAND:
 17760   
             case REGEX:
 17761   
             case REPLACE:
 17762   
             case ROUND:
 17763   
             case SAMETERM:
 17764   
             case SAMPLE:
 17765   
             case SECONDS:
 17766   
             case SHA1:
 17767   
             case SHA224:
 17768   
             case SHA256:
 17769   
             case SHA384:
 17770   
             case SHA512:
 17771   
             case STR:
 17772   
             case STRAFTER:
 17773   
             case STRBEFORE:
 17774   
             case STRDT:
 17775   
             case STRENDS:
 17776   
             case STRING_LITERAL1:
 17777   
             case STRING_LITERAL2:
 17778   
             case STRING_LITERAL_LONG1:
 17779   
             case STRING_LITERAL_LONG2:
 17780   
             case STRLANG:
 17781   
             case STRLEN:
 17782   
             case STRSTARTS:
 17783   
             case SUBSTR:
 17784   
             case SUM:
 17785   
             case TIMEZONE:
 17786   
             case TRUE:
 17787   
             case TZ:
 17788   
             case UCASE:
 17789   
             case URI:
 17790   
             case VAR1:
 17791   
             case VAR2:
 17792   
             case YEAR:
 17793   
                 {
 17794  2268 
                 alt124=4;
 17795   
                 }
 17796  2268 
                 break;
 17797   
             default:
 17798  0 
                 NoViableAltException nvae =
 17799   
                     new NoViableAltException("", 124, 0, input);
 17800   
 
 17801  0 
                 throw nvae;
 17802   
 
 17803   
             }
 17804   
 
 17805  2308 
             switch (alt124) {
 17806   
                 case 1 :
 17807   
                     // com\\googlecode\\sparkleg\\Sparql.g:530:7: NEGATION primaryExpression
 17808   
                     {
 17809  38 
                     NEGATION370=(Token)match(input,NEGATION,FOLLOW_NEGATION_in_unaryExpression4890);
 17810  38 
                     stream_NEGATION.add(NEGATION370);
 17811   
 
 17812   
 
 17813  38 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4892);
 17814  38 
                     primaryExpression371=primaryExpression();
 17815   
 
 17816  38 
                     state._fsp--;
 17817   
 
 17818  38 
                     stream_primaryExpression.add(primaryExpression371.getTree());
 17819   
 
 17820   
                     // AST REWRITE
 17821   
                     // elements: NEGATION, primaryExpression
 17822   
                     // token labels:
 17823   
                     // rule labels: retval
 17824   
                     // token list labels:
 17825   
                     // rule list labels:
 17826   
                     // wildcard labels:
 17827  38 
                     retval.tree = root_0;
 17828  38 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17829   
 
 17830  38 
                     root_0 = (Object)adaptor.nil();
 17831   
                     // 530:34: -> ^( UNARY NEGATION primaryExpression )
 17832   
                     {
 17833   
                         // com\\googlecode\\sparkleg\\Sparql.g:530:37: ^( UNARY NEGATION primaryExpression )
 17834   
                         {
 17835  38 
                         Object root_1 = (Object)adaptor.nil();
 17836  38 
                         root_1 = (Object)adaptor.becomeRoot(
 17837   
                         (Object)adaptor.create(UNARY, "UNARY")
 17838   
                         , root_1);
 17839   
 
 17840  38 
                         adaptor.addChild(root_1,
 17841   
                         stream_NEGATION.nextNode()
 17842   
                         );
 17843   
 
 17844  38 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17845   
 
 17846  38 
                         adaptor.addChild(root_0, root_1);
 17847   
                         }
 17848   
 
 17849   
                     }
 17850   
 
 17851   
 
 17852  38 
                     retval.tree = root_0;
 17853   
 
 17854   
                     }
 17855  38 
                     break;
 17856   
                 case 2 :
 17857   
                     // com\\googlecode\\sparkleg\\Sparql.g:531:7: PLUS primaryExpression
 17858   
                     {
 17859  0 
                     PLUS372=(Token)match(input,PLUS,FOLLOW_PLUS_in_unaryExpression4910);
 17860  0 
                     stream_PLUS.add(PLUS372);
 17861   
 
 17862   
 
 17863  0 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4912);
 17864  0 
                     primaryExpression373=primaryExpression();
 17865   
 
 17866  0 
                     state._fsp--;
 17867   
 
 17868  0 
                     stream_primaryExpression.add(primaryExpression373.getTree());
 17869   
 
 17870   
                     // AST REWRITE
 17871   
                     // elements: PLUS, primaryExpression
 17872   
                     // token labels:
 17873   
                     // rule labels: retval
 17874   
                     // token list labels:
 17875   
                     // rule list labels:
 17876   
                     // wildcard labels:
 17877  0 
                     retval.tree = root_0;
 17878  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17879   
 
 17880  0 
                     root_0 = (Object)adaptor.nil();
 17881   
                     // 531:30: -> ^( UNARY PLUS primaryExpression )
 17882   
                     {
 17883   
                         // com\\googlecode\\sparkleg\\Sparql.g:531:33: ^( UNARY PLUS primaryExpression )
 17884   
                         {
 17885  0 
                         Object root_1 = (Object)adaptor.nil();
 17886  0 
                         root_1 = (Object)adaptor.becomeRoot(
 17887   
                         (Object)adaptor.create(UNARY, "UNARY")
 17888   
                         , root_1);
 17889   
 
 17890  0 
                         adaptor.addChild(root_1,
 17891   
                         stream_PLUS.nextNode()
 17892   
                         );
 17893   
 
 17894  0 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17895   
 
 17896  0 
                         adaptor.addChild(root_0, root_1);
 17897   
                         }
 17898   
 
 17899   
                     }
 17900   
 
 17901   
 
 17902  0 
                     retval.tree = root_0;
 17903   
 
 17904   
                     }
 17905  0 
                     break;
 17906   
                 case 3 :
 17907   
                     // com\\googlecode\\sparkleg\\Sparql.g:532:7: MINUS primaryExpression
 17908   
                     {
 17909  2 
                     MINUS374=(Token)match(input,MINUS,FOLLOW_MINUS_in_unaryExpression4930);
 17910  2 
                     stream_MINUS.add(MINUS374);
 17911   
 
 17912   
 
 17913  2 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4932);
 17914  2 
                     primaryExpression375=primaryExpression();
 17915   
 
 17916  2 
                     state._fsp--;
 17917   
 
 17918  2 
                     stream_primaryExpression.add(primaryExpression375.getTree());
 17919   
 
 17920   
                     // AST REWRITE
 17921   
                     // elements: MINUS, primaryExpression
 17922   
                     // token labels:
 17923   
                     // rule labels: retval
 17924   
                     // token list labels:
 17925   
                     // rule list labels:
 17926   
                     // wildcard labels:
 17927  2 
                     retval.tree = root_0;
 17928  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17929   
 
 17930  2 
                     root_0 = (Object)adaptor.nil();
 17931   
                     // 532:31: -> ^( UNARY MINUS primaryExpression )
 17932   
                     {
 17933   
                         // com\\googlecode\\sparkleg\\Sparql.g:532:34: ^( UNARY MINUS primaryExpression )
 17934   
                         {
 17935  2 
                         Object root_1 = (Object)adaptor.nil();
 17936  2 
                         root_1 = (Object)adaptor.becomeRoot(
 17937   
                         (Object)adaptor.create(UNARY, "UNARY")
 17938   
                         , root_1);
 17939   
 
 17940  2 
                         adaptor.addChild(root_1,
 17941   
                         stream_MINUS.nextNode()
 17942   
                         );
 17943   
 
 17944  2 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17945   
 
 17946  2 
                         adaptor.addChild(root_0, root_1);
 17947   
                         }
 17948   
 
 17949   
                     }
 17950   
 
 17951   
 
 17952  2 
                     retval.tree = root_0;
 17953   
 
 17954   
                     }
 17955  2 
                     break;
 17956   
                 case 4 :
 17957   
                     // com\\googlecode\\sparkleg\\Sparql.g:533:7: primaryExpression
 17958   
                     {
 17959  2268 
                     pushFollow(FOLLOW_primaryExpression_in_unaryExpression4950);
 17960  2268 
                     primaryExpression376=primaryExpression();
 17961   
 
 17962  2268 
                     state._fsp--;
 17963   
 
 17964  2268 
                     stream_primaryExpression.add(primaryExpression376.getTree());
 17965   
 
 17966   
                     // AST REWRITE
 17967   
                     // elements: primaryExpression
 17968   
                     // token labels:
 17969   
                     // rule labels: retval
 17970   
                     // token list labels:
 17971   
                     // rule list labels:
 17972   
                     // wildcard labels:
 17973  2268 
                     retval.tree = root_0;
 17974  2268 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 17975   
 
 17976  2268 
                     root_0 = (Object)adaptor.nil();
 17977   
                     // 533:25: -> ^( UNARY primaryExpression )
 17978   
                     {
 17979   
                         // com\\googlecode\\sparkleg\\Sparql.g:533:28: ^( UNARY primaryExpression )
 17980   
                         {
 17981  2268 
                         Object root_1 = (Object)adaptor.nil();
 17982  2268 
                         root_1 = (Object)adaptor.becomeRoot(
 17983   
                         (Object)adaptor.create(UNARY, "UNARY")
 17984   
                         , root_1);
 17985   
 
 17986  2268 
                         adaptor.addChild(root_1, stream_primaryExpression.nextTree());
 17987   
 
 17988  2268 
                         adaptor.addChild(root_0, root_1);
 17989   
                         }
 17990   
 
 17991   
                     }
 17992   
 
 17993   
 
 17994  2268 
                     retval.tree = root_0;
 17995   
 
 17996   
                     }
 17997   
                     break;
 17998   
 
 17999   
             }
 18000  2308 
             retval.stop = input.LT(-1);
 18001   
 
 18002   
 
 18003  2308 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18004  2308 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18005   
 
 18006   
         }
 18007  0 
         catch (RecognitionException re) {
 18008  0 
             reportError(re);
 18009  0 
             recover(input,re);
 18010  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18011   
 
 18012   
         }
 18013   
 
 18014  0 
         finally {
 18015   
                 // do for sure before leaving
 18016  2308 
         }
 18017  2308 
         return retval;
 18018   
     }
 18019   
     // $ANTLR end "unaryExpression"
 18020   
 
 18021   
 
 18022  2308 
     public static class primaryExpression_return extends ParserRuleReturnScope {
 18023   
         Object tree;
 18024  2308 
         public Object getTree() { return tree; }
 18025   
     };
 18026   
 
 18027   
 
 18028   
     // $ANTLR start "primaryExpression"
 18029   
     // com\\googlecode\\sparkleg\\Sparql.g:536:1: primaryExpression : ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate );
 18030   
     public final SparqlParser.primaryExpression_return primaryExpression() throws RecognitionException {
 18031  2308 
         SparqlParser.primaryExpression_return retval = new SparqlParser.primaryExpression_return();
 18032  2308 
         retval.start = input.LT(1);
 18033   
 
 18034   
 
 18035  2308 
         Object root_0 = null;
 18036   
 
 18037  2308 
         SparqlParser.brackettedExpression_return brackettedExpression377 =null;
 18038   
 
 18039  2308 
         SparqlParser.builtInCall_return builtInCall378 =null;
 18040   
 
 18041  2308 
         SparqlParser.iriRefOrFunction_return iriRefOrFunction379 =null;
 18042   
 
 18043  2308 
         SparqlParser.rdfLiteral_return rdfLiteral380 =null;
 18044   
 
 18045  2308 
         SparqlParser.numericLiteral_return numericLiteral381 =null;
 18046   
 
 18047  2308 
         SparqlParser.booleanLiteral_return booleanLiteral382 =null;
 18048   
 
 18049  2308 
         SparqlParser.var_return var383 =null;
 18050   
 
 18051  2308 
         SparqlParser.aggregate_return aggregate384 =null;
 18052   
 
 18053   
 
 18054   
 
 18055   
         try {
 18056   
             // com\\googlecode\\sparkleg\\Sparql.g:537:5: ( brackettedExpression | builtInCall | iriRefOrFunction | rdfLiteral | numericLiteral | booleanLiteral | var | aggregate )
 18057  2308 
             int alt125=8;
 18058  2308 
             switch ( input.LA(1) ) {
 18059   
             case OPEN_BRACE:
 18060   
                 {
 18061  48 
                 alt125=1;
 18062   
                 }
 18063  48 
                 break;
 18064   
             case ABS:
 18065   
             case BNODE:
 18066   
             case BOUND:
 18067   
             case CEIL:
 18068   
             case COALESCE:
 18069   
             case CONCAT:
 18070   
             case CONTAINS:
 18071   
             case DATATYPE:
 18072   
             case DAY:
 18073   
             case ENCODE_FOR_URI:
 18074   
             case EXISTS:
 18075   
             case FLOOR:
 18076   
             case HOURS:
 18077   
             case IF:
 18078   
             case IRI:
 18079   
             case ISBLANK:
 18080   
             case ISIRI:
 18081   
             case ISLITERAL:
 18082   
             case ISNUMERIC:
 18083   
             case ISURI:
 18084   
             case LANG:
 18085   
             case LANGMATCHES:
 18086   
             case LCASE:
 18087   
             case MD5:
 18088   
             case MINUTES:
 18089   
             case MONTH:
 18090   
             case NOT:
 18091   
             case NOW:
 18092   
             case RAND:
 18093   
             case REGEX:
 18094   
             case REPLACE:
 18095   
             case ROUND:
 18096   
             case SAMETERM:
 18097   
             case SECONDS:
 18098   
             case SHA1:
 18099   
             case SHA224:
 18100   
             case SHA256:
 18101   
             case SHA384:
 18102   
             case SHA512:
 18103   
             case STR:
 18104   
             case STRAFTER:
 18105   
             case STRBEFORE:
 18106   
             case STRDT:
 18107   
             case STRENDS:
 18108   
             case STRLANG:
 18109   
             case STRLEN:
 18110   
             case STRSTARTS:
 18111   
             case SUBSTR:
 18112   
             case TIMEZONE:
 18113   
             case TZ:
 18114   
             case UCASE:
 18115   
             case URI:
 18116   
             case YEAR:
 18117   
                 {
 18118  374 
                 alt125=2;
 18119   
                 }
 18120  374 
                 break;
 18121   
             case IRI_REF:
 18122   
             case PNAME_LN:
 18123   
             case PNAME_NS:
 18124   
                 {
 18125  178 
                 alt125=3;
 18126   
                 }
 18127  178 
                 break;
 18128   
             case STRING_LITERAL1:
 18129   
             case STRING_LITERAL2:
 18130   
             case STRING_LITERAL_LONG1:
 18131   
             case STRING_LITERAL_LONG2:
 18132   
                 {
 18133  208 
                 alt125=4;
 18134   
                 }
 18135  208 
                 break;
 18136   
             case DECIMAL:
 18137   
             case DECIMAL_NEGATIVE:
 18138   
             case DECIMAL_POSITIVE:
 18139   
             case DOUBLE:
 18140   
             case DOUBLE_NEGATIVE:
 18141   
             case DOUBLE_POSITIVE:
 18142   
             case INTEGER:
 18143   
             case INTEGER_NEGATIVE:
 18144   
             case INTEGER_POSITIVE:
 18145   
                 {
 18146  206 
                 alt125=5;
 18147   
                 }
 18148  206 
                 break;
 18149   
             case FALSE:
 18150   
             case TRUE:
 18151   
                 {
 18152  12 
                 alt125=6;
 18153   
                 }
 18154  12 
                 break;
 18155   
             case VAR1:
 18156   
             case VAR2:
 18157   
                 {
 18158  1176 
                 alt125=7;
 18159   
                 }
 18160  1176 
                 break;
 18161   
             case AVG:
 18162   
             case COUNT:
 18163   
             case GROUP_CONCAT:
 18164   
             case MAX:
 18165   
             case MIN:
 18166   
             case SAMPLE:
 18167   
             case SUM:
 18168   
                 {
 18169  106 
                 alt125=8;
 18170   
                 }
 18171  106 
                 break;
 18172   
             default:
 18173  0 
                 NoViableAltException nvae =
 18174   
                     new NoViableAltException("", 125, 0, input);
 18175   
 
 18176  0 
                 throw nvae;
 18177   
 
 18178   
             }
 18179   
 
 18180  2308 
             switch (alt125) {
 18181   
                 case 1 :
 18182   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:7: brackettedExpression
 18183   
                     {
 18184  48 
                     root_0 = (Object)adaptor.nil();
 18185   
 
 18186   
 
 18187  48 
                     pushFollow(FOLLOW_brackettedExpression_in_primaryExpression4975);
 18188  48 
                     brackettedExpression377=brackettedExpression();
 18189   
 
 18190  48 
                     state._fsp--;
 18191   
 
 18192  48 
                     adaptor.addChild(root_0, brackettedExpression377.getTree());
 18193   
 
 18194   
                     }
 18195  48 
                     break;
 18196   
                 case 2 :
 18197   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:30: builtInCall
 18198   
                     {
 18199  374 
                     root_0 = (Object)adaptor.nil();
 18200   
 
 18201   
 
 18202  374 
                     pushFollow(FOLLOW_builtInCall_in_primaryExpression4979);
 18203  374 
                     builtInCall378=builtInCall();
 18204   
 
 18205  374 
                     state._fsp--;
 18206   
 
 18207  374 
                     adaptor.addChild(root_0, builtInCall378.getTree());
 18208   
 
 18209   
                     }
 18210  374 
                     break;
 18211   
                 case 3 :
 18212   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:44: iriRefOrFunction
 18213   
                     {
 18214  178 
                     root_0 = (Object)adaptor.nil();
 18215   
 
 18216   
 
 18217  178 
                     pushFollow(FOLLOW_iriRefOrFunction_in_primaryExpression4983);
 18218  178 
                     iriRefOrFunction379=iriRefOrFunction();
 18219   
 
 18220  178 
                     state._fsp--;
 18221   
 
 18222  178 
                     adaptor.addChild(root_0, iriRefOrFunction379.getTree());
 18223   
 
 18224   
                     }
 18225  178 
                     break;
 18226   
                 case 4 :
 18227   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:63: rdfLiteral
 18228   
                     {
 18229  208 
                     root_0 = (Object)adaptor.nil();
 18230   
 
 18231   
 
 18232  208 
                     pushFollow(FOLLOW_rdfLiteral_in_primaryExpression4987);
 18233  208 
                     rdfLiteral380=rdfLiteral();
 18234   
 
 18235  208 
                     state._fsp--;
 18236   
 
 18237  208 
                     adaptor.addChild(root_0, rdfLiteral380.getTree());
 18238   
 
 18239   
                     }
 18240  208 
                     break;
 18241   
                 case 5 :
 18242   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:76: numericLiteral
 18243   
                     {
 18244  206 
                     root_0 = (Object)adaptor.nil();
 18245   
 
 18246   
 
 18247  206 
                     pushFollow(FOLLOW_numericLiteral_in_primaryExpression4991);
 18248  206 
                     numericLiteral381=numericLiteral();
 18249   
 
 18250  206 
                     state._fsp--;
 18251   
 
 18252  206 
                     adaptor.addChild(root_0, numericLiteral381.getTree());
 18253   
 
 18254   
                     }
 18255  206 
                     break;
 18256   
                 case 6 :
 18257   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:93: booleanLiteral
 18258   
                     {
 18259  12 
                     root_0 = (Object)adaptor.nil();
 18260   
 
 18261   
 
 18262  12 
                     pushFollow(FOLLOW_booleanLiteral_in_primaryExpression4995);
 18263  12 
                     booleanLiteral382=booleanLiteral();
 18264   
 
 18265  12 
                     state._fsp--;
 18266   
 
 18267  12 
                     adaptor.addChild(root_0, booleanLiteral382.getTree());
 18268   
 
 18269   
                     }
 18270  12 
                     break;
 18271   
                 case 7 :
 18272   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:110: var
 18273   
                     {
 18274  1176 
                     root_0 = (Object)adaptor.nil();
 18275   
 
 18276   
 
 18277  1176 
                     pushFollow(FOLLOW_var_in_primaryExpression4999);
 18278  1176 
                     var383=var();
 18279   
 
 18280  1176 
                     state._fsp--;
 18281   
 
 18282  1176 
                     adaptor.addChild(root_0, var383.getTree());
 18283   
 
 18284   
                     }
 18285  1176 
                     break;
 18286   
                 case 8 :
 18287   
                     // com\\googlecode\\sparkleg\\Sparql.g:537:116: aggregate
 18288   
                     {
 18289  106 
                     root_0 = (Object)adaptor.nil();
 18290   
 
 18291   
 
 18292  106 
                     pushFollow(FOLLOW_aggregate_in_primaryExpression5003);
 18293  106 
                     aggregate384=aggregate();
 18294   
 
 18295  106 
                     state._fsp--;
 18296   
 
 18297  106 
                     adaptor.addChild(root_0, aggregate384.getTree());
 18298   
 
 18299   
                     }
 18300   
                     break;
 18301   
 
 18302   
             }
 18303  2308 
             retval.stop = input.LT(-1);
 18304   
 
 18305   
 
 18306  2308 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18307  2308 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18308   
 
 18309   
         }
 18310  0 
         catch (RecognitionException re) {
 18311  0 
             reportError(re);
 18312  0 
             recover(input,re);
 18313  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18314   
 
 18315   
         }
 18316   
 
 18317  0 
         finally {
 18318   
                 // do for sure before leaving
 18319  2308 
         }
 18320  2308 
         return retval;
 18321   
     }
 18322   
     // $ANTLR end "primaryExpression"
 18323   
 
 18324   
 
 18325  534 
     public static class brackettedExpression_return extends ParserRuleReturnScope {
 18326   
         Object tree;
 18327  534 
         public Object getTree() { return tree; }
 18328   
     };
 18329   
 
 18330   
 
 18331   
     // $ANTLR start "brackettedExpression"
 18332   
     // com\\googlecode\\sparkleg\\Sparql.g:540:1: brackettedExpression : OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) ;
 18333   
     public final SparqlParser.brackettedExpression_return brackettedExpression() throws RecognitionException {
 18334  534 
         SparqlParser.brackettedExpression_return retval = new SparqlParser.brackettedExpression_return();
 18335  534 
         retval.start = input.LT(1);
 18336   
 
 18337   
 
 18338  534 
         Object root_0 = null;
 18339   
 
 18340  534 
         Token OPEN_BRACE385=null;
 18341  534 
         Token CLOSE_BRACE387=null;
 18342  534 
         SparqlParser.expression_return expression386 =null;
 18343   
 
 18344   
 
 18345  534 
         Object OPEN_BRACE385_tree=null;
 18346  534 
         Object CLOSE_BRACE387_tree=null;
 18347  534 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18348  534 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18349  534 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18350   
         try {
 18351   
             // com\\googlecode\\sparkleg\\Sparql.g:541:5: ( OPEN_BRACE expression CLOSE_BRACE -> ^( BRACKETTED_EXPRESSION expression ) )
 18352   
             // com\\googlecode\\sparkleg\\Sparql.g:541:7: OPEN_BRACE expression CLOSE_BRACE
 18353   
             {
 18354  534 
             OPEN_BRACE385=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_brackettedExpression5020);
 18355  534 
             stream_OPEN_BRACE.add(OPEN_BRACE385);
 18356   
 
 18357   
 
 18358  534 
             pushFollow(FOLLOW_expression_in_brackettedExpression5022);
 18359  534 
             expression386=expression();
 18360   
 
 18361  534 
             state._fsp--;
 18362   
 
 18363  534 
             stream_expression.add(expression386.getTree());
 18364   
 
 18365  534 
             CLOSE_BRACE387=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_brackettedExpression5024);
 18366  534 
             stream_CLOSE_BRACE.add(CLOSE_BRACE387);
 18367   
 
 18368   
 
 18369   
             // AST REWRITE
 18370   
             // elements: expression
 18371   
             // token labels:
 18372   
             // rule labels: retval
 18373   
             // token list labels:
 18374   
             // rule list labels:
 18375   
             // wildcard labels:
 18376  534 
             retval.tree = root_0;
 18377  534 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 18378   
 
 18379  534 
             root_0 = (Object)adaptor.nil();
 18380   
             // 541:41: -> ^( BRACKETTED_EXPRESSION expression )
 18381   
             {
 18382   
                 // com\\googlecode\\sparkleg\\Sparql.g:541:44: ^( BRACKETTED_EXPRESSION expression )
 18383   
                 {
 18384  534 
                 Object root_1 = (Object)adaptor.nil();
 18385  534 
                 root_1 = (Object)adaptor.becomeRoot(
 18386   
                 (Object)adaptor.create(BRACKETTED_EXPRESSION, "BRACKETTED_EXPRESSION")
 18387   
                 , root_1);
 18388   
 
 18389  534 
                 adaptor.addChild(root_1, stream_expression.nextTree());
 18390   
 
 18391  534 
                 adaptor.addChild(root_0, root_1);
 18392   
                 }
 18393   
 
 18394   
             }
 18395   
 
 18396   
 
 18397  534 
             retval.tree = root_0;
 18398   
 
 18399   
             }
 18400   
 
 18401  534 
             retval.stop = input.LT(-1);
 18402   
 
 18403   
 
 18404  534 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 18405  534 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 18406   
 
 18407   
         }
 18408  0 
         catch (RecognitionException re) {
 18409  0 
             reportError(re);
 18410  0 
             recover(input,re);
 18411  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 18412   
 
 18413   
         }
 18414   
 
 18415  0 
         finally {
 18416   
                 // do for sure before leaving
 18417  534 
         }
 18418  534 
         return retval;
 18419   
     }
 18420   
     // $ANTLR end "brackettedExpression"
 18421   
 
 18422   
 
 18423  532 
     public static class builtInCall_return extends ParserRuleReturnScope {
 18424   
         Object tree;
 18425  532 
         public Object getTree() { return tree; }
 18426   
     };
 18427   
 
 18428   
 
 18429   
     // $ANTLR start "builtInCall"
 18430   
     // com\\googlecode\\sparkleg\\Sparql.g:544:1: builtInCall : ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction );
 18431   
     public final SparqlParser.builtInCall_return builtInCall() throws RecognitionException {
 18432  532 
         SparqlParser.builtInCall_return retval = new SparqlParser.builtInCall_return();
 18433  532 
         retval.start = input.LT(1);
 18434   
 
 18435   
 
 18436  532 
         Object root_0 = null;
 18437   
 
 18438  532 
         Token STR388=null;
 18439  532 
         Token OPEN_BRACE389=null;
 18440  532 
         Token CLOSE_BRACE391=null;
 18441  532 
         Token LANG392=null;
 18442  532 
         Token OPEN_BRACE393=null;
 18443  532 
         Token CLOSE_BRACE395=null;
 18444  532 
         Token LANGMATCHES396=null;
 18445  532 
         Token OPEN_BRACE397=null;
 18446  532 
         Token COMMA399=null;
 18447  532 
         Token CLOSE_BRACE401=null;
 18448  532 
         Token DATATYPE402=null;
 18449  532 
         Token OPEN_BRACE403=null;
 18450  532 
         Token CLOSE_BRACE405=null;
 18451  532 
         Token BOUND406=null;
 18452  532 
         Token OPEN_BRACE407=null;
 18453  532 
         Token CLOSE_BRACE409=null;
 18454  532 
         Token IRI410=null;
 18455  532 
         Token OPEN_BRACE411=null;
 18456  532 
         Token CLOSE_BRACE413=null;
 18457  532 
         Token URI414=null;
 18458  532 
         Token OPEN_BRACE415=null;
 18459  532 
         Token CLOSE_BRACE417=null;
 18460  532 
         Token BNODE418=null;
 18461  532 
         Token OPEN_BRACE419=null;
 18462  532 
         Token CLOSE_BRACE421=null;
 18463  532 
         Token BNODE422=null;
 18464  532 
         Token RAND424=null;
 18465  532 
         Token ABS426=null;
 18466  532 
         Token OPEN_BRACE427=null;
 18467  532 
         Token CLOSE_BRACE429=null;
 18468  532 
         Token CEIL430=null;
 18469  532 
         Token OPEN_BRACE431=null;
 18470  532 
         Token CLOSE_BRACE433=null;
 18471  532 
         Token FLOOR434=null;
 18472  532 
         Token OPEN_BRACE435=null;
 18473  532 
         Token CLOSE_BRACE437=null;
 18474  532 
         Token ROUND438=null;
 18475  532 
         Token OPEN_BRACE439=null;
 18476  532 
         Token CLOSE_BRACE441=null;
 18477  532 
         Token CONCAT442=null;
 18478  532 
         Token STRLEN445=null;
 18479  532 
         Token OPEN_BRACE446=null;
 18480  532 
         Token CLOSE_BRACE448=null;
 18481  532 
         Token UCASE449=null;
 18482  532 
         Token OPEN_BRACE450=null;
 18483  532 
         Token CLOSE_BRACE452=null;
 18484  532 
         Token LCASE453=null;
 18485  532 
         Token OPEN_BRACE454=null;
 18486  532 
         Token CLOSE_BRACE456=null;
 18487  532 
         Token ENCODE_FOR_URI457=null;
 18488  532 
         Token OPEN_BRACE458=null;
 18489  532 
         Token CLOSE_BRACE460=null;
 18490  532 
         Token CONTAINS461=null;
 18491  532 
         Token OPEN_BRACE462=null;
 18492  532 
         Token COMMA464=null;
 18493  532 
         Token CLOSE_BRACE466=null;
 18494  532 
         Token STRSTARTS467=null;
 18495  532 
         Token OPEN_BRACE468=null;
 18496  532 
         Token COMMA470=null;
 18497  532 
         Token CLOSE_BRACE472=null;
 18498  532 
         Token STRENDS473=null;
 18499  532 
         Token OPEN_BRACE474=null;
 18500  532 
         Token COMMA476=null;
 18501  532 
         Token CLOSE_BRACE478=null;
 18502  532 
         Token STRBEFORE479=null;
 18503  532 
         Token OPEN_BRACE480=null;
 18504  532 
         Token COMMA482=null;
 18505  532 
         Token CLOSE_BRACE484=null;
 18506  532 
         Token STRAFTER485=null;
 18507  532 
         Token OPEN_BRACE486=null;
 18508  532 
         Token COMMA488=null;
 18509  532 
         Token CLOSE_BRACE490=null;
 18510  532 
         Token REPLACE491=null;
 18511  532 
         Token OPEN_BRACE492=null;
 18512  532 
         Token COMMA494=null;
 18513  532 
         Token COMMA496=null;
 18514  532 
         Token CLOSE_BRACE498=null;
 18515  532 
         Token YEAR499=null;
 18516  532 
         Token OPEN_BRACE500=null;
 18517  532 
         Token CLOSE_BRACE502=null;
 18518  532 
         Token MONTH503=null;
 18519  532 
         Token OPEN_BRACE504=null;
 18520  532 
         Token CLOSE_BRACE506=null;
 18521  532 
         Token DAY507=null;
 18522  532 
         Token OPEN_BRACE508=null;
 18523  532 
         Token CLOSE_BRACE510=null;
 18524  532 
         Token HOURS511=null;
 18525  532 
         Token OPEN_BRACE512=null;
 18526  532 
         Token CLOSE_BRACE514=null;
 18527  532 
         Token MINUTES515=null;
 18528  532 
         Token OPEN_BRACE516=null;
 18529  532 
         Token CLOSE_BRACE518=null;
 18530  532 
         Token SECONDS519=null;
 18531  532 
         Token OPEN_BRACE520=null;
 18532  532 
         Token CLOSE_BRACE522=null;
 18533  532 
         Token TIMEZONE523=null;
 18534  532 
         Token OPEN_BRACE524=null;
 18535  532 
         Token CLOSE_BRACE526=null;
 18536  532 
         Token TZ527=null;
 18537  532 
         Token OPEN_BRACE528=null;
 18538  532 
         Token CLOSE_BRACE530=null;
 18539  532 
         Token NOW531=null;
 18540  532 
         Token MD5533=null;
 18541  532 
         Token OPEN_BRACE534=null;
 18542  532 
         Token CLOSE_BRACE536=null;
 18543  532 
         Token SHA1537=null;
 18544  532 
         Token OPEN_BRACE538=null;
 18545  532 
         Token CLOSE_BRACE540=null;
 18546  532 
         Token SHA224541=null;
 18547  532 
         Token OPEN_BRACE542=null;
 18548  532 
         Token CLOSE_BRACE544=null;
 18549  532 
         Token SHA256545=null;
 18550  532 
         Token OPEN_BRACE546=null;
 18551  532 
         Token CLOSE_BRACE548=null;
 18552  532 
         Token SHA384549=null;
 18553  532 
         Token OPEN_BRACE550=null;
 18554  532 
         Token CLOSE_BRACE552=null;
 18555  532 
         Token SHA512553=null;
 18556  532 
         Token OPEN_BRACE554=null;
 18557  532 
         Token CLOSE_BRACE556=null;
 18558  532 
         Token COALESCE557=null;
 18559  532 
         Token IF559=null;
 18560  532 
         Token OPEN_BRACE560=null;
 18561  532 
         Token COMMA561=null;
 18562  532 
         Token COMMA562=null;
 18563  532 
         Token CLOSE_BRACE563=null;
 18564  532 
         Token STRLANG564=null;
 18565  532 
         Token OPEN_BRACE565=null;
 18566  532 
         Token COMMA567=null;
 18567  532 
         Token CLOSE_BRACE569=null;
 18568  532 
         Token STRDT570=null;
 18569  532 
         Token OPEN_BRACE571=null;
 18570  532 
         Token COMMA573=null;
 18571  532 
         Token CLOSE_BRACE575=null;
 18572  532 
         Token SAMETERM576=null;
 18573  532 
         Token OPEN_BRACE577=null;
 18574  532 
         Token COMMA579=null;
 18575  532 
         Token CLOSE_BRACE581=null;
 18576  532 
         Token ISIRI582=null;
 18577  532 
         Token OPEN_BRACE583=null;
 18578  532 
         Token CLOSE_BRACE585=null;
 18579  532 
         Token ISURI586=null;
 18580  532 
         Token OPEN_BRACE587=null;
 18581  532 
         Token CLOSE_BRACE589=null;
 18582  532 
         Token ISBLANK590=null;
 18583  532 
         Token OPEN_BRACE591=null;
 18584  532 
         Token CLOSE_BRACE593=null;
 18585  532 
         Token ISLITERAL594=null;
 18586  532 
         Token OPEN_BRACE595=null;
 18587  532 
         Token CLOSE_BRACE597=null;
 18588  532 
         Token ISNUMERIC598=null;
 18589  532 
         Token OPEN_BRACE599=null;
 18590  532 
         Token CLOSE_BRACE601=null;
 18591  532 
         SparqlParser.expression_return e1 =null;
 18592   
 
 18593  532 
         SparqlParser.expression_return e2 =null;
 18594   
 
 18595  532 
         SparqlParser.expression_return e3 =null;
 18596   
 
 18597  532 
         SparqlParser.expression_return expression390 =null;
 18598   
 
 18599  532 
         SparqlParser.expression_return expression394 =null;
 18600   
 
 18601  532 
         SparqlParser.expression_return expression398 =null;
 18602   
 
 18603  532 
         SparqlParser.expression_return expression400 =null;
 18604   
 
 18605  532 
         SparqlParser.expression_return expression404 =null;
 18606   
 
 18607  532 
         SparqlParser.var_return var408 =null;
 18608   
 
 18609  532 
         SparqlParser.expression_return expression412 =null;
 18610   
 
 18611  532 
         SparqlParser.expression_return expression416 =null;
 18612   
 
 18613  532 
         SparqlParser.expression_return expression420 =null;
 18614   
 
 18615  532 
         SparqlParser.nil_return nil423 =null;
 18616   
 
 18617  532 
         SparqlParser.nil_return nil425 =null;
 18618   
 
 18619  532 
         SparqlParser.expression_return expression428 =null;
 18620   
 
 18621  532 
         SparqlParser.expression_return expression432 =null;
 18622   
 
 18623  532 
         SparqlParser.expression_return expression436 =null;
 18624   
 
 18625  532 
         SparqlParser.expression_return expression440 =null;
 18626   
 
 18627  532 
         SparqlParser.expressionList_return expressionList443 =null;
 18628   
 
 18629  532 
         SparqlParser.subStringExpression_return subStringExpression444 =null;
 18630   
 
 18631  532 
         SparqlParser.expression_return expression447 =null;
 18632   
 
 18633  532 
         SparqlParser.expression_return expression451 =null;
 18634   
 
 18635  532 
         SparqlParser.expression_return expression455 =null;
 18636   
 
 18637  532 
         SparqlParser.expression_return expression459 =null;
 18638   
 
 18639  532 
         SparqlParser.expression_return expression463 =null;
 18640   
 
 18641  532 
         SparqlParser.expression_return expression465 =null;
 18642   
 
 18643  532 
         SparqlParser.expression_return expression469 =null;
 18644   
 
 18645  532 
         SparqlParser.expression_return expression471 =null;
 18646   
 
 18647  532 
         SparqlParser.expression_return expression475 =null;
 18648   
 
 18649  532 
         SparqlParser.expression_return expression477 =null;
 18650   
 
 18651  532 
         SparqlParser.expression_return expression481 =null;
 18652   
 
 18653  532 
         SparqlParser.expression_return expression483 =null;
 18654   
 
 18655  532 
         SparqlParser.expression_return expression487 =null;
 18656   
 
 18657  532 
         SparqlParser.expression_return expression489 =null;
 18658   
 
 18659  532 
         SparqlParser.expression_return expression493 =null;
 18660   
 
 18661  532 
         SparqlParser.expression_return expression495 =null;
 18662   
 
 18663  532 
         SparqlParser.expression_return expression497 =null;
 18664   
 
 18665  532 
         SparqlParser.expression_return expression501 =null;
 18666   
 
 18667  532 
         SparqlParser.expression_return expression505 =null;
 18668   
 
 18669  532 
         SparqlParser.expression_return expression509 =null;
 18670   
 
 18671  532 
         SparqlParser.expression_return expression513 =null;
 18672   
 
 18673  532 
         SparqlParser.expression_return expression517 =null;
 18674   
 
 18675  532 
         SparqlParser.expression_return expression521 =null;
 18676   
 
 18677  532 
         SparqlParser.expression_return expression525 =null;
 18678   
 
 18679  532 
         SparqlParser.expression_return expression529 =null;
 18680   
 
 18681  532 
         SparqlParser.nil_return nil532 =null;
 18682   
 
 18683  532 
         SparqlParser.expression_return expression535 =null;
 18684   
 
 18685  532 
         SparqlParser.expression_return expression539 =null;
 18686   
 
 18687  532 
         SparqlParser.expression_return expression543 =null;
 18688   
 
 18689  532 
         SparqlParser.expression_return expression547 =null;
 18690   
 
 18691  532 
         SparqlParser.expression_return expression551 =null;
 18692   
 
 18693  532 
         SparqlParser.expression_return expression555 =null;
 18694   
 
 18695  532 
         SparqlParser.expressionList_return expressionList558 =null;
 18696   
 
 18697  532 
         SparqlParser.expression_return expression566 =null;
 18698   
 
 18699  532 
         SparqlParser.expression_return expression568 =null;
 18700   
 
 18701  532 
         SparqlParser.expression_return expression572 =null;
 18702   
 
 18703  532 
         SparqlParser.expression_return expression574 =null;
 18704   
 
 18705  532 
         SparqlParser.expression_return expression578 =null;
 18706   
 
 18707  532 
         SparqlParser.expression_return expression580 =null;
 18708   
 
 18709  532 
         SparqlParser.expression_return expression584 =null;
 18710   
 
 18711  532 
         SparqlParser.expression_return expression588 =null;
 18712   
 
 18713  532 
         SparqlParser.expression_return expression592 =null;
 18714   
 
 18715  532 
         SparqlParser.expression_return expression596 =null;
 18716   
 
 18717  532 
         SparqlParser.expression_return expression600 =null;
 18718   
 
 18719  532 
         SparqlParser.regexExpression_return regexExpression602 =null;
 18720   
 
 18721  532 
         SparqlParser.existsFunction_return existsFunction603 =null;
 18722   
 
 18723  532 
         SparqlParser.notExistsFunction_return notExistsFunction604 =null;
 18724   
 
 18725   
 
 18726  532 
         Object STR388_tree=null;
 18727  532 
         Object OPEN_BRACE389_tree=null;
 18728  532 
         Object CLOSE_BRACE391_tree=null;
 18729  532 
         Object LANG392_tree=null;
 18730  532 
         Object OPEN_BRACE393_tree=null;
 18731  532 
         Object CLOSE_BRACE395_tree=null;
 18732  532 
         Object LANGMATCHES396_tree=null;
 18733  532 
         Object OPEN_BRACE397_tree=null;
 18734  532 
         Object COMMA399_tree=null;
 18735  532 
         Object CLOSE_BRACE401_tree=null;
 18736  532 
         Object DATATYPE402_tree=null;
 18737  532 
         Object OPEN_BRACE403_tree=null;
 18738  532 
         Object CLOSE_BRACE405_tree=null;
 18739  532 
         Object BOUND406_tree=null;
 18740  532 
         Object OPEN_BRACE407_tree=null;
 18741  532 
         Object CLOSE_BRACE409_tree=null;
 18742  532 
         Object IRI410_tree=null;
 18743  532 
         Object OPEN_BRACE411_tree=null;
 18744  532 
         Object CLOSE_BRACE413_tree=null;
 18745  532 
         Object URI414_tree=null;
 18746  532 
         Object OPEN_BRACE415_tree=null;
 18747  532 
         Object CLOSE_BRACE417_tree=null;
 18748  532 
         Object BNODE418_tree=null;
 18749  532 
         Object OPEN_BRACE419_tree=null;
 18750  532 
         Object CLOSE_BRACE421_tree=null;
 18751  532 
         Object BNODE422_tree=null;
 18752  532 
         Object RAND424_tree=null;
 18753  532 
         Object ABS426_tree=null;
 18754  532 
         Object OPEN_BRACE427_tree=null;
 18755  532 
         Object CLOSE_BRACE429_tree=null;
 18756  532 
         Object CEIL430_tree=null;
 18757  532 
         Object OPEN_BRACE431_tree=null;
 18758  532 
         Object CLOSE_BRACE433_tree=null;
 18759  532 
         Object FLOOR434_tree=null;
 18760  532 
         Object OPEN_BRACE435_tree=null;
 18761  532 
         Object CLOSE_BRACE437_tree=null;
 18762  532 
         Object ROUND438_tree=null;
 18763  532 
         Object OPEN_BRACE439_tree=null;
 18764  532 
         Object CLOSE_BRACE441_tree=null;
 18765  532 
         Object CONCAT442_tree=null;
 18766  532 
         Object STRLEN445_tree=null;
 18767  532 
         Object OPEN_BRACE446_tree=null;
 18768  532 
         Object CLOSE_BRACE448_tree=null;
 18769  532 
         Object UCASE449_tree=null;
 18770  532 
         Object OPEN_BRACE450_tree=null;
 18771  532 
         Object CLOSE_BRACE452_tree=null;
 18772  532 
         Object LCASE453_tree=null;
 18773  532 
         Object OPEN_BRACE454_tree=null;
 18774  532 
         Object CLOSE_BRACE456_tree=null;
 18775  532 
         Object ENCODE_FOR_URI457_tree=null;
 18776  532 
         Object OPEN_BRACE458_tree=null;
 18777  532 
         Object CLOSE_BRACE460_tree=null;
 18778  532 
         Object CONTAINS461_tree=null;
 18779  532 
         Object OPEN_BRACE462_tree=null;
 18780  532 
         Object COMMA464_tree=null;
 18781  532 
         Object CLOSE_BRACE466_tree=null;
 18782  532 
         Object STRSTARTS467_tree=null;
 18783  532 
         Object OPEN_BRACE468_tree=null;
 18784  532 
         Object COMMA470_tree=null;
 18785  532 
         Object CLOSE_BRACE472_tree=null;
 18786  532 
         Object STRENDS473_tree=null;
 18787  532 
         Object OPEN_BRACE474_tree=null;
 18788  532 
         Object COMMA476_tree=null;
 18789  532 
         Object CLOSE_BRACE478_tree=null;
 18790  532 
         Object STRBEFORE479_tree=null;
 18791  532 
         Object OPEN_BRACE480_tree=null;
 18792  532 
         Object COMMA482_tree=null;
 18793  532 
         Object CLOSE_BRACE484_tree=null;
 18794  532 
         Object STRAFTER485_tree=null;
 18795  532 
         Object OPEN_BRACE486_tree=null;
 18796  532 
         Object COMMA488_tree=null;
 18797  532 
         Object CLOSE_BRACE490_tree=null;
 18798  532 
         Object REPLACE491_tree=null;
 18799  532 
         Object OPEN_BRACE492_tree=null;
 18800  532 
         Object COMMA494_tree=null;
 18801  532 
         Object COMMA496_tree=null;
 18802  532 
         Object CLOSE_BRACE498_tree=null;
 18803  532 
         Object YEAR499_tree=null;
 18804  532 
         Object OPEN_BRACE500_tree=null;
 18805  532 
         Object CLOSE_BRACE502_tree=null;
 18806  532 
         Object MONTH503_tree=null;
 18807  532 
         Object OPEN_BRACE504_tree=null;
 18808  532 
         Object CLOSE_BRACE506_tree=null;
 18809  532 
         Object DAY507_tree=null;
 18810  532 
         Object OPEN_BRACE508_tree=null;
 18811  532 
         Object CLOSE_BRACE510_tree=null;
 18812  532 
         Object HOURS511_tree=null;
 18813  532 
         Object OPEN_BRACE512_tree=null;
 18814  532 
         Object CLOSE_BRACE514_tree=null;
 18815  532 
         Object MINUTES515_tree=null;
 18816  532 
         Object OPEN_BRACE516_tree=null;
 18817  532 
         Object CLOSE_BRACE518_tree=null;
 18818  532 
         Object SECONDS519_tree=null;
 18819  532 
         Object OPEN_BRACE520_tree=null;
 18820  532 
         Object CLOSE_BRACE522_tree=null;
 18821  532 
         Object TIMEZONE523_tree=null;
 18822  532 
         Object OPEN_BRACE524_tree=null;
 18823  532 
         Object CLOSE_BRACE526_tree=null;
 18824  532 
         Object TZ527_tree=null;
 18825  532 
         Object OPEN_BRACE528_tree=null;
 18826  532 
         Object CLOSE_BRACE530_tree=null;
 18827  532 
         Object NOW531_tree=null;
 18828  532 
         Object MD5533_tree=null;
 18829  532 
         Object OPEN_BRACE534_tree=null;
 18830  532 
         Object CLOSE_BRACE536_tree=null;
 18831  532 
         Object SHA1537_tree=null;
 18832  532 
         Object OPEN_BRACE538_tree=null;
 18833  532 
         Object CLOSE_BRACE540_tree=null;
 18834  532 
         Object SHA224541_tree=null;
 18835  532 
         Object OPEN_BRACE542_tree=null;
 18836  532 
         Object CLOSE_BRACE544_tree=null;
 18837  532 
         Object SHA256545_tree=null;
 18838  532 
         Object OPEN_BRACE546_tree=null;
 18839  532 
         Object CLOSE_BRACE548_tree=null;
 18840  532 
         Object SHA384549_tree=null;
 18841  532 
         Object OPEN_BRACE550_tree=null;
 18842  532 
         Object CLOSE_BRACE552_tree=null;
 18843  532 
         Object SHA512553_tree=null;
 18844  532 
         Object OPEN_BRACE554_tree=null;
 18845  532 
         Object CLOSE_BRACE556_tree=null;
 18846  532 
         Object COALESCE557_tree=null;
 18847  532 
         Object IF559_tree=null;
 18848  532 
         Object OPEN_BRACE560_tree=null;
 18849  532 
         Object COMMA561_tree=null;
 18850  532 
         Object COMMA562_tree=null;
 18851  532 
         Object CLOSE_BRACE563_tree=null;
 18852  532 
         Object STRLANG564_tree=null;
 18853  532 
         Object OPEN_BRACE565_tree=null;
 18854  532 
         Object COMMA567_tree=null;
 18855  532 
         Object CLOSE_BRACE569_tree=null;
 18856  532 
         Object STRDT570_tree=null;
 18857  532 
         Object OPEN_BRACE571_tree=null;
 18858  532 
         Object COMMA573_tree=null;
 18859  532 
         Object CLOSE_BRACE575_tree=null;
 18860  532 
         Object SAMETERM576_tree=null;
 18861  532 
         Object OPEN_BRACE577_tree=null;
 18862  532 
         Object COMMA579_tree=null;
 18863  532 
         Object CLOSE_BRACE581_tree=null;
 18864  532 
         Object ISIRI582_tree=null;
 18865  532 
         Object OPEN_BRACE583_tree=null;
 18866  532 
         Object CLOSE_BRACE585_tree=null;
 18867  532 
         Object ISURI586_tree=null;
 18868  532 
         Object OPEN_BRACE587_tree=null;
 18869  532 
         Object CLOSE_BRACE589_tree=null;
 18870  532 
         Object ISBLANK590_tree=null;
 18871  532 
         Object OPEN_BRACE591_tree=null;
 18872  532 
         Object CLOSE_BRACE593_tree=null;
 18873  532 
         Object ISLITERAL594_tree=null;
 18874  532 
         Object OPEN_BRACE595_tree=null;
 18875  532 
         Object CLOSE_BRACE597_tree=null;
 18876  532 
         Object ISNUMERIC598_tree=null;
 18877  532 
         Object OPEN_BRACE599_tree=null;
 18878  532 
         Object CLOSE_BRACE601_tree=null;
 18879  532 
         RewriteRuleTokenStream stream_SHA256=new RewriteRuleTokenStream(adaptor,"token SHA256");
 18880  532 
         RewriteRuleTokenStream stream_YEAR=new RewriteRuleTokenStream(adaptor,"token YEAR");
 18881  532 
         RewriteRuleTokenStream stream_TIMEZONE=new RewriteRuleTokenStream(adaptor,"token TIMEZONE");
 18882  532 
         RewriteRuleTokenStream stream_CONTAINS=new RewriteRuleTokenStream(adaptor,"token CONTAINS");
 18883  532 
         RewriteRuleTokenStream stream_STRENDS=new RewriteRuleTokenStream(adaptor,"token STRENDS");
 18884  532 
         RewriteRuleTokenStream stream_LCASE=new RewriteRuleTokenStream(adaptor,"token LCASE");
 18885  532 
         RewriteRuleTokenStream stream_BNODE=new RewriteRuleTokenStream(adaptor,"token BNODE");
 18886  532 
         RewriteRuleTokenStream stream_SHA512=new RewriteRuleTokenStream(adaptor,"token SHA512");
 18887  532 
         RewriteRuleTokenStream stream_SECONDS=new RewriteRuleTokenStream(adaptor,"token SECONDS");
 18888  532 
         RewriteRuleTokenStream stream_NOW=new RewriteRuleTokenStream(adaptor,"token NOW");
 18889  532 
         RewriteRuleTokenStream stream_DAY=new RewriteRuleTokenStream(adaptor,"token DAY");
 18890  532 
         RewriteRuleTokenStream stream_SHA224=new RewriteRuleTokenStream(adaptor,"token SHA224");
 18891  532 
         RewriteRuleTokenStream stream_STRAFTER=new RewriteRuleTokenStream(adaptor,"token STRAFTER");
 18892  532 
         RewriteRuleTokenStream stream_STRLEN=new RewriteRuleTokenStream(adaptor,"token STRLEN");
 18893  532 
         RewriteRuleTokenStream stream_MONTH=new RewriteRuleTokenStream(adaptor,"token MONTH");
 18894  532 
         RewriteRuleTokenStream stream_ENCODE_FOR_URI=new RewriteRuleTokenStream(adaptor,"token ENCODE_FOR_URI");
 18895  532 
         RewriteRuleTokenStream stream_IF=new RewriteRuleTokenStream(adaptor,"token IF");
 18896  532 
         RewriteRuleTokenStream stream_ISURI=new RewriteRuleTokenStream(adaptor,"token ISURI");
 18897  532 
         RewriteRuleTokenStream stream_STR=new RewriteRuleTokenStream(adaptor,"token STR");
 18898  532 
         RewriteRuleTokenStream stream_ISLITERAL=new RewriteRuleTokenStream(adaptor,"token ISLITERAL");
 18899  532 
         RewriteRuleTokenStream stream_STRDT=new RewriteRuleTokenStream(adaptor,"token STRDT");
 18900  532 
         RewriteRuleTokenStream stream_SAMETERM=new RewriteRuleTokenStream(adaptor,"token SAMETERM");
 18901  532 
         RewriteRuleTokenStream stream_MD5=new RewriteRuleTokenStream(adaptor,"token MD5");
 18902  532 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 18903  532 
         RewriteRuleTokenStream stream_RAND=new RewriteRuleTokenStream(adaptor,"token RAND");
 18904  532 
         RewriteRuleTokenStream stream_REPLACE=new RewriteRuleTokenStream(adaptor,"token REPLACE");
 18905  532 
         RewriteRuleTokenStream stream_IRI=new RewriteRuleTokenStream(adaptor,"token IRI");
 18906  532 
         RewriteRuleTokenStream stream_LANGMATCHES=new RewriteRuleTokenStream(adaptor,"token LANGMATCHES");
 18907  532 
         RewriteRuleTokenStream stream_TZ=new RewriteRuleTokenStream(adaptor,"token TZ");
 18908  532 
         RewriteRuleTokenStream stream_STRLANG=new RewriteRuleTokenStream(adaptor,"token STRLANG");
 18909  532 
         RewriteRuleTokenStream stream_BOUND=new RewriteRuleTokenStream(adaptor,"token BOUND");
 18910  532 
         RewriteRuleTokenStream stream_ISIRI=new RewriteRuleTokenStream(adaptor,"token ISIRI");
 18911  532 
         RewriteRuleTokenStream stream_COALESCE=new RewriteRuleTokenStream(adaptor,"token COALESCE");
 18912  532 
         RewriteRuleTokenStream stream_ISNUMERIC=new RewriteRuleTokenStream(adaptor,"token ISNUMERIC");
 18913  532 
         RewriteRuleTokenStream stream_CONCAT=new RewriteRuleTokenStream(adaptor,"token CONCAT");
 18914  532 
         RewriteRuleTokenStream stream_STRSTARTS=new RewriteRuleTokenStream(adaptor,"token STRSTARTS");
 18915  532 
         RewriteRuleTokenStream stream_STRBEFORE=new RewriteRuleTokenStream(adaptor,"token STRBEFORE");
 18916  532 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 18917  532 
         RewriteRuleTokenStream stream_SHA1=new RewriteRuleTokenStream(adaptor,"token SHA1");
 18918  532 
         RewriteRuleTokenStream stream_FLOOR=new RewriteRuleTokenStream(adaptor,"token FLOOR");
 18919  532 
         RewriteRuleTokenStream stream_ISBLANK=new RewriteRuleTokenStream(adaptor,"token ISBLANK");
 18920  532 
         RewriteRuleTokenStream stream_UCASE=new RewriteRuleTokenStream(adaptor,"token UCASE");
 18921  532 
         RewriteRuleTokenStream stream_URI=new RewriteRuleTokenStream(adaptor,"token URI");
 18922  532 
         RewriteRuleTokenStream stream_ABS=new RewriteRuleTokenStream(adaptor,"token ABS");
 18923  532 
         RewriteRuleTokenStream stream_MINUTES=new RewriteRuleTokenStream(adaptor,"token MINUTES");
 18924  532 
         RewriteRuleTokenStream stream_ROUND=new RewriteRuleTokenStream(adaptor,"token ROUND");
 18925  532 
         RewriteRuleTokenStream stream_CEIL=new RewriteRuleTokenStream(adaptor,"token CEIL");
 18926  532 
         RewriteRuleTokenStream stream_DATATYPE=new RewriteRuleTokenStream(adaptor,"token DATATYPE");
 18927  532 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 18928  532 
         RewriteRuleTokenStream stream_SHA384=new RewriteRuleTokenStream(adaptor,"token SHA384");
 18929  532 
         RewriteRuleTokenStream stream_HOURS=new RewriteRuleTokenStream(adaptor,"token HOURS");
 18930  532 
         RewriteRuleTokenStream stream_LANG=new RewriteRuleTokenStream(adaptor,"token LANG");
 18931  532 
         RewriteRuleSubtreeStream stream_existsFunction=new RewriteRuleSubtreeStream(adaptor,"rule existsFunction");
 18932  532 
         RewriteRuleSubtreeStream stream_subStringExpression=new RewriteRuleSubtreeStream(adaptor,"rule subStringExpression");
 18933  532 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 18934  532 
         RewriteRuleSubtreeStream stream_notExistsFunction=new RewriteRuleSubtreeStream(adaptor,"rule notExistsFunction");
 18935  532 
         RewriteRuleSubtreeStream stream_expressionList=new RewriteRuleSubtreeStream(adaptor,"rule expressionList");
 18936  532 
         RewriteRuleSubtreeStream stream_var=new RewriteRuleSubtreeStream(adaptor,"rule var");
 18937  532 
         RewriteRuleSubtreeStream stream_regexExpression=new RewriteRuleSubtreeStream(adaptor,"rule regexExpression");
 18938  532 
         RewriteRuleSubtreeStream stream_nil=new RewriteRuleSubtreeStream(adaptor,"rule nil");
 18939   
         try {
 18940   
             // com\\googlecode\\sparkleg\\Sparql.g:545:5: ( STR OPEN_BRACE expression CLOSE_BRACE -> ^( STR expression ) | LANG OPEN_BRACE expression CLOSE_BRACE -> ^( LANG expression ) | LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( LANGMATCHES ( expression )+ ) | DATATYPE OPEN_BRACE expression CLOSE_BRACE -> ^( DATATYPE expression ) | BOUND OPEN_BRACE var CLOSE_BRACE -> ^( BOUND var ) | IRI OPEN_BRACE expression CLOSE_BRACE -> ^( IRI expression ) | URI OPEN_BRACE expression CLOSE_BRACE -> ^( URI expression ) | BNODE ( OPEN_BRACE expression CLOSE_BRACE ) -> ^( BNODE expression ) | BNODE nil -> BNODE | RAND nil -> RAND | ABS OPEN_BRACE expression CLOSE_BRACE -> ^( ABS expression ) | CEIL OPEN_BRACE expression CLOSE_BRACE -> ^( CEIL expression ) | FLOOR OPEN_BRACE expression CLOSE_BRACE -> ^( FLOOR expression ) | ROUND OPEN_BRACE expression CLOSE_BRACE -> ^( ROUND expression ) | CONCAT expressionList -> ^( CONCAT expressionList ) | subStringExpression -> subStringExpression | STRLEN OPEN_BRACE expression CLOSE_BRACE -> ^( STRLEN expression ) | UCASE OPEN_BRACE expression CLOSE_BRACE -> ^( UCASE expression ) | LCASE OPEN_BRACE expression CLOSE_BRACE -> ^( LCASE expression ) | ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE -> ^( ENCODE_FOR_URI expression ) | CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( CONTAINS expression expression ) | STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRSTARTS expression expression ) | STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRENDS expression expression ) | STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRBEFORE expression expression ) | STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRAFTER expression expression ) | REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE -> ^( REPLACE expression expression expression ) | YEAR OPEN_BRACE expression CLOSE_BRACE -> ^( YEAR expression ) | MONTH OPEN_BRACE expression CLOSE_BRACE -> ^( MONTH expression ) | DAY OPEN_BRACE expression CLOSE_BRACE -> ^( DAY expression ) | HOURS OPEN_BRACE expression CLOSE_BRACE -> ^( HOURS expression ) | MINUTES OPEN_BRACE expression CLOSE_BRACE -> ^( MINUTES expression ) | SECONDS OPEN_BRACE expression CLOSE_BRACE -> ^( SECONDS expression ) | TIMEZONE OPEN_BRACE expression CLOSE_BRACE -> ^( TIMEZONE expression ) | TZ OPEN_BRACE expression CLOSE_BRACE -> ^( TZ expression ) | NOW nil -> NOW | MD5 OPEN_BRACE expression CLOSE_BRACE -> ^( MD5 expression ) | SHA1 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA1 expression ) | SHA224 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA224 expression ) | SHA256 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA256 expression ) | SHA384 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA384 expression ) | SHA512 OPEN_BRACE expression CLOSE_BRACE -> ^( SHA512 expression ) | COALESCE expressionList -> ^( COALESCE expressionList ) | IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE -> ^( IF $e1 $e2 $e3) | STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRLANG expression expression ) | STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( STRDT expression expression ) | SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE -> ^( SAMETERM expression expression ) | ISIRI OPEN_BRACE expression CLOSE_BRACE -> ^( ISIRI expression ) | ISURI OPEN_BRACE expression CLOSE_BRACE -> ^( ISURI expression ) | ISBLANK OPEN_BRACE expression CLOSE_BRACE -> ^( ISBLANK expression ) | ISLITERAL OPEN_BRACE expression CLOSE_BRACE -> ^( ISLITERAL expression ) | ISNUMERIC OPEN_BRACE expression CLOSE_BRACE -> ^( ISNUMERIC expression ) | regexExpression -> regexExpression | existsFunction -> existsFunction | notExistsFunction -> notExistsFunction )
 18941  532 
             int alt126=54;
 18942  532 
             switch ( input.LA(1) ) {
 18943   
             case STR:
 18944   
                 {
 18945  36 
                 alt126=1;
 18946   
                 }
 18947  36 
                 break;
 18948   
             case LANG:
 18949   
                 {
 18950  40 
                 alt126=2;
 18951   
                 }
 18952  40 
                 break;
 18953   
             case LANGMATCHES:
 18954   
                 {
 18955  30 
                 alt126=3;
 18956   
                 }
 18957  30 
                 break;
 18958   
             case DATATYPE:
 18959   
                 {
 18960  100 
                 alt126=4;
 18961   
                 }
 18962  100 
                 break;
 18963   
             case BOUND:
 18964   
                 {
 18965  30 
                 alt126=5;
 18966   
                 }
 18967  30 
                 break;
 18968   
             case IRI:
 18969   
                 {
 18970  2 
                 alt126=6;
 18971   
                 }
 18972  2 
                 break;
 18973   
             case URI:
 18974   
                 {
 18975  2 
                 alt126=7;
 18976   
                 }
 18977  2 
                 break;
 18978   
             case BNODE:
 18979   
                 {
 18980  8 
                 switch ( input.LA(2) ) {
 18981   
                 case OPEN_BRACE:
 18982   
                     {
 18983  8 
                     switch ( input.LA(3) ) {
 18984   
                     case CLOSE_BRACE:
 18985   
                         {
 18986  4 
                         alt126=9;
 18987   
                         }
 18988  4 
                         break;
 18989   
                     case ABS:
 18990   
                     case AVG:
 18991   
                     case BNODE:
 18992   
                     case BOUND:
 18993   
                     case CEIL:
 18994   
                     case COALESCE:
 18995   
                     case CONCAT:
 18996   
                     case CONTAINS:
 18997   
                     case COUNT:
 18998   
                     case DATATYPE:
 18999   
                     case DAY:
 19000   
                     case DECIMAL:
 19001   
                     case DECIMAL_NEGATIVE:
 19002   
                     case DECIMAL_POSITIVE:
 19003   
                     case DOUBLE:
 19004   
                     case DOUBLE_NEGATIVE:
 19005   
                     case DOUBLE_POSITIVE:
 19006   
                     case ENCODE_FOR_URI:
 19007   
                     case EXISTS:
 19008   
                     case FALSE:
 19009   
                     case FLOOR:
 19010   
                     case GROUP_CONCAT:
 19011   
                     case HOURS:
 19012   
                     case IF:
 19013   
                     case INTEGER:
 19014   
                     case INTEGER_NEGATIVE:
 19015   
                     case INTEGER_POSITIVE:
 19016   
                     case IRI:
 19017   
                     case IRI_REF:
 19018   
                     case ISBLANK:
 19019   
                     case ISIRI:
 19020   
                     case ISLITERAL:
 19021   
                     case ISNUMERIC:
 19022   
                     case ISURI:
 19023   
                     case LANG:
 19024   
                     case LANGMATCHES:
 19025   
                     case LCASE:
 19026   
                     case MAX:
 19027   
                     case MD5:
 19028   
                     case MIN:
 19029   
                     case MINUS:
 19030   
                     case MINUTES:
 19031   
                     case MONTH:
 19032   
                     case NEGATION:
 19033   
                     case NOT:
 19034   
                     case NOW:
 19035   
                     case OPEN_BRACE:
 19036   
                     case PLUS:
 19037   
                     case PNAME_LN:
 19038   
                     case PNAME_NS:
 19039   
                     case RAND:
 19040   
                     case REGEX:
 19041   
                     case REPLACE:
 19042   
                     case ROUND:
 19043   
                     case SAMETERM:
 19044   
                     case SAMPLE:
 19045   
                     case SECONDS:
 19046   
                     case SHA1:
 19047   
                     case SHA224:
 19048   
                     case SHA256:
 19049   
                     case SHA384:
 19050   
                     case SHA512:
 19051   
                     case STR:
 19052   
                     case STRAFTER:
 19053   
                     case STRBEFORE:
 19054   
                     case STRDT:
 19055   
                     case STRENDS:
 19056   
                     case STRING_LITERAL1:
 19057   
                     case STRING_LITERAL2:
 19058   
                     case STRING_LITERAL_LONG1:
 19059   
                     case STRING_LITERAL_LONG2:
 19060   
                     case STRLANG:
 19061   
                     case STRLEN:
 19062   
                     case STRSTARTS:
 19063   
                     case SUBSTR:
 19064   
                     case SUM:
 19065   
                     case TIMEZONE:
 19066   
                     case TRUE:
 19067   
                     case TZ:
 19068   
                     case UCASE:
 19069   
                     case URI:
 19070   
                     case VAR1:
 19071   
                     case VAR2:
 19072   
                     case YEAR:
 19073   
                         {
 19074  4 
                         alt126=8;
 19075   
                         }
 19076  4 
                         break;
 19077   
                     default:
 19078  0 
                         NoViableAltException nvae =
 19079   
                             new NoViableAltException("", 126, 54, input);
 19080   
 
 19081  0 
                         throw nvae;
 19082   
 
 19083   
                     }
 19084   
 
 19085   
                     }
 19086  8 
                     break;
 19087   
                 default:
 19088  0 
                     NoViableAltException nvae =
 19089   
                         new NoViableAltException("", 126, 8, input);
 19090   
 
 19091  0 
                     throw nvae;
 19092   
 
 19093   
                 }
 19094   
 
 19095   
                 }
 19096  8 
                 break;
 19097   
             case RAND:
 19098   
                 {
 19099  2 
                 alt126=10;
 19100   
                 }
 19101  2 
                 break;
 19102   
             case ABS:
 19103   
                 {
 19104  2 
                 alt126=11;
 19105   
                 }
 19106  2 
                 break;
 19107   
             case CEIL:
 19108   
                 {
 19109  2 
                 alt126=12;
 19110   
                 }
 19111  2 
                 break;
 19112   
             case FLOOR:
 19113   
                 {
 19114  2 
                 alt126=13;
 19115   
                 }
 19116  2 
                 break;
 19117   
             case ROUND:
 19118   
                 {
 19119  2 
                 alt126=14;
 19120   
                 }
 19121  2 
                 break;
 19122   
             case CONCAT:
 19123   
                 {
 19124  10 
                 alt126=15;
 19125   
                 }
 19126  10 
                 break;
 19127   
             case SUBSTR:
 19128   
                 {
 19129  4 
                 alt126=16;
 19130   
                 }
 19131  4 
                 break;
 19132   
             case STRLEN:
 19133   
                 {
 19134  2 
                 alt126=17;
 19135   
                 }
 19136  2 
                 break;
 19137   
             case UCASE:
 19138   
                 {
 19139  2 
                 alt126=18;
 19140   
                 }
 19141  2 
                 break;
 19142   
             case LCASE:
 19143   
                 {
 19144  2 
                 alt126=19;
 19145   
                 }
 19146  2 
                 break;
 19147   
             case ENCODE_FOR_URI:
 19148   
                 {
 19149  2 
                 alt126=20;
 19150   
                 }
 19151  2 
                 break;
 19152   
             case CONTAINS:
 19153   
                 {
 19154  2 
                 alt126=21;
 19155   
                 }
 19156  2 
                 break;
 19157   
             case STRSTARTS:
 19158   
                 {
 19159  2 
                 alt126=22;
 19160   
                 }
 19161  2 
                 break;
 19162   
             case STRENDS:
 19163   
                 {
 19164  2 
                 alt126=23;
 19165   
                 }
 19166  2 
                 break;
 19167   
             case STRBEFORE:
 19168   
                 {
 19169  2 
                 alt126=24;
 19170   
                 }
 19171  2 
                 break;
 19172   
             case STRAFTER:
 19173   
                 {
 19174  2 
                 alt126=25;
 19175   
                 }
 19176  2 
                 break;
 19177   
             case REPLACE:
 19178   
                 {
 19179  6 
                 alt126=26;
 19180   
                 }
 19181  6 
                 break;
 19182   
             case YEAR:
 19183   
                 {
 19184  2 
                 alt126=27;
 19185   
                 }
 19186  2 
                 break;
 19187   
             case MONTH:
 19188   
                 {
 19189  2 
                 alt126=28;
 19190   
                 }
 19191  2 
                 break;
 19192   
             case DAY:
 19193   
                 {
 19194  2 
                 alt126=29;
 19195   
                 }
 19196  2 
                 break;
 19197   
             case HOURS:
 19198   
                 {
 19199  2 
                 alt126=30;
 19200   
                 }
 19201  2 
                 break;
 19202   
             case MINUTES:
 19203   
                 {
 19204  2 
                 alt126=31;
 19205   
                 }
 19206  2 
                 break;
 19207   
             case SECONDS:
 19208   
                 {
 19209  2 
                 alt126=32;
 19210   
                 }
 19211  2 
                 break;
 19212   
             case TIMEZONE:
 19213   
                 {
 19214  2 
                 alt126=33;
 19215   
                 }
 19216  2 
                 break;
 19217   
             case TZ:
 19218   
                 {
 19219  2 
                 alt126=34;
 19220   
                 }
 19221  2 
                 break;
 19222   
             case NOW:
 19223   
                 {
 19224  2 
                 alt126=35;
 19225   
                 }
 19226  2 
                 break;
 19227   
             case MD5:
 19228   
                 {
 19229  4 
                 alt126=36;
 19230   
                 }
 19231  4 
                 break;
 19232   
             case SHA1:
 19233   
                 {
 19234  4 
                 alt126=37;
 19235   
                 }
 19236  4 
                 break;
 19237   
             case SHA224:
 19238   
                 {
 19239  0 
                 alt126=38;
 19240   
                 }
 19241  0 
                 break;
 19242   
             case SHA256:
 19243   
                 {
 19244  4 
                 alt126=39;
 19245   
                 }
 19246  4 
                 break;
 19247   
             case SHA384:
 19248   
                 {
 19249  4 
                 alt126=40;
 19250   
                 }
 19251  4 
                 break;
 19252   
             case SHA512:
 19253   
                 {
 19254  4 
                 alt126=41;
 19255   
                 }
 19256  4 
                 break;
 19257   
             case COALESCE:
 19258   
                 {
 19259  12 
                 alt126=42;
 19260   
                 }
 19261  12 
                 break;
 19262   
             case IF:
 19263   
                 {
 19264  6 
                 alt126=43;
 19265   
                 }
 19266  6 
                 break;
 19267   
             case STRLANG:
 19268   
                 {
 19269  6 
                 alt126=44;
 19270   
                 }
 19271  6 
                 break;
 19272   
             case STRDT:
 19273   
                 {
 19274  6 
                 alt126=45;
 19275   
                 }
 19276  6 
                 break;
 19277   
             case SAMETERM:
 19278   
                 {
 19279  30 
                 alt126=46;
 19280   
                 }
 19281  30 
                 break;
 19282   
             case ISIRI:
 19283   
                 {
 19284  8 
                 alt126=47;
 19285   
                 }
 19286  8 
                 break;
 19287   
             case ISURI:
 19288   
                 {
 19289  2 
                 alt126=48;
 19290   
                 }
 19291  2 
                 break;
 19292   
             case ISBLANK:
 19293   
                 {
 19294  8 
                 alt126=49;
 19295   
                 }
 19296  8 
                 break;
 19297   
             case ISLITERAL:
 19298   
                 {
 19299  8 
                 alt126=50;
 19300   
                 }
 19301  8 
                 break;
 19302   
             case ISNUMERIC:
 19303   
                 {
 19304  4 
                 alt126=51;
 19305   
                 }
 19306  4 
                 break;
 19307   
             case REGEX:
 19308   
                 {
 19309  42 
                 alt126=52;
 19310   
                 }
 19311  42 
                 break;
 19312   
             case EXISTS:
 19313   
                 {
 19314  20 
                 alt126=53;
 19315   
                 }
 19316  20 
                 break;
 19317   
             case NOT:
 19318   
                 {
 19319  46 
                 alt126=54;
 19320   
                 }
 19321  46 
                 break;
 19322   
             default:
 19323  0 
                 NoViableAltException nvae =
 19324   
                     new NoViableAltException("", 126, 0, input);
 19325   
 
 19326  0 
                 throw nvae;
 19327   
 
 19328   
             }
 19329   
 
 19330  532 
             switch (alt126) {
 19331   
                 case 1 :
 19332   
                     // com\\googlecode\\sparkleg\\Sparql.g:545:7: STR OPEN_BRACE expression CLOSE_BRACE
 19333   
                     {
 19334  36 
                     STR388=(Token)match(input,STR,FOLLOW_STR_in_builtInCall5049);
 19335  36 
                     stream_STR.add(STR388);
 19336   
 
 19337   
 
 19338  36 
                     OPEN_BRACE389=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5051);
 19339  36 
                     stream_OPEN_BRACE.add(OPEN_BRACE389);
 19340   
 
 19341   
 
 19342  36 
                     pushFollow(FOLLOW_expression_in_builtInCall5053);
 19343  36 
                     expression390=expression();
 19344   
 
 19345  36 
                     state._fsp--;
 19346   
 
 19347  36 
                     stream_expression.add(expression390.getTree());
 19348   
 
 19349  36 
                     CLOSE_BRACE391=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5055);
 19350  36 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE391);
 19351   
 
 19352   
 
 19353   
                     // AST REWRITE
 19354   
                     // elements: STR, expression
 19355   
                     // token labels:
 19356   
                     // rule labels: retval
 19357   
                     // token list labels:
 19358   
                     // rule list labels:
 19359   
                     // wildcard labels:
 19360  36 
                     retval.tree = root_0;
 19361  36 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19362   
 
 19363  36 
                     root_0 = (Object)adaptor.nil();
 19364   
                     // 545:45: -> ^( STR expression )
 19365   
                     {
 19366   
                         // com\\googlecode\\sparkleg\\Sparql.g:545:48: ^( STR expression )
 19367   
                         {
 19368  36 
                         Object root_1 = (Object)adaptor.nil();
 19369  36 
                         root_1 = (Object)adaptor.becomeRoot(
 19370   
                         stream_STR.nextNode()
 19371   
                         , root_1);
 19372   
 
 19373  36 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19374   
 
 19375  36 
                         adaptor.addChild(root_0, root_1);
 19376   
                         }
 19377   
 
 19378   
                     }
 19379   
 
 19380   
 
 19381  36 
                     retval.tree = root_0;
 19382   
 
 19383   
                     }
 19384  36 
                     break;
 19385   
                 case 2 :
 19386   
                     // com\\googlecode\\sparkleg\\Sparql.g:546:7: LANG OPEN_BRACE expression CLOSE_BRACE
 19387   
                     {
 19388  40 
                     LANG392=(Token)match(input,LANG,FOLLOW_LANG_in_builtInCall5071);
 19389  40 
                     stream_LANG.add(LANG392);
 19390   
 
 19391   
 
 19392  40 
                     OPEN_BRACE393=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5073);
 19393  40 
                     stream_OPEN_BRACE.add(OPEN_BRACE393);
 19394   
 
 19395   
 
 19396  40 
                     pushFollow(FOLLOW_expression_in_builtInCall5075);
 19397  40 
                     expression394=expression();
 19398   
 
 19399  40 
                     state._fsp--;
 19400   
 
 19401  40 
                     stream_expression.add(expression394.getTree());
 19402   
 
 19403  40 
                     CLOSE_BRACE395=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5077);
 19404  40 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE395);
 19405   
 
 19406   
 
 19407   
                     // AST REWRITE
 19408   
                     // elements: expression, LANG
 19409   
                     // token labels:
 19410   
                     // rule labels: retval
 19411   
                     // token list labels:
 19412   
                     // rule list labels:
 19413   
                     // wildcard labels:
 19414  40 
                     retval.tree = root_0;
 19415  40 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19416   
 
 19417  40 
                     root_0 = (Object)adaptor.nil();
 19418   
                     // 546:46: -> ^( LANG expression )
 19419   
                     {
 19420   
                         // com\\googlecode\\sparkleg\\Sparql.g:546:49: ^( LANG expression )
 19421   
                         {
 19422  40 
                         Object root_1 = (Object)adaptor.nil();
 19423  40 
                         root_1 = (Object)adaptor.becomeRoot(
 19424   
                         stream_LANG.nextNode()
 19425   
                         , root_1);
 19426   
 
 19427  40 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19428   
 
 19429  40 
                         adaptor.addChild(root_0, root_1);
 19430   
                         }
 19431   
 
 19432   
                     }
 19433   
 
 19434   
 
 19435  40 
                     retval.tree = root_0;
 19436   
 
 19437   
                     }
 19438  40 
                     break;
 19439   
                 case 3 :
 19440   
                     // com\\googlecode\\sparkleg\\Sparql.g:547:7: LANGMATCHES OPEN_BRACE expression COMMA expression CLOSE_BRACE
 19441   
                     {
 19442  30 
                     LANGMATCHES396=(Token)match(input,LANGMATCHES,FOLLOW_LANGMATCHES_in_builtInCall5093);
 19443  30 
                     stream_LANGMATCHES.add(LANGMATCHES396);
 19444   
 
 19445   
 
 19446  30 
                     OPEN_BRACE397=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5095);
 19447  30 
                     stream_OPEN_BRACE.add(OPEN_BRACE397);
 19448   
 
 19449   
 
 19450  30 
                     pushFollow(FOLLOW_expression_in_builtInCall5097);
 19451  30 
                     expression398=expression();
 19452   
 
 19453  30 
                     state._fsp--;
 19454   
 
 19455  30 
                     stream_expression.add(expression398.getTree());
 19456   
 
 19457  30 
                     COMMA399=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5099);
 19458  30 
                     stream_COMMA.add(COMMA399);
 19459   
 
 19460   
 
 19461  30 
                     pushFollow(FOLLOW_expression_in_builtInCall5101);
 19462  30 
                     expression400=expression();
 19463   
 
 19464  30 
                     state._fsp--;
 19465   
 
 19466  30 
                     stream_expression.add(expression400.getTree());
 19467   
 
 19468  30 
                     CLOSE_BRACE401=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5103);
 19469  30 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE401);
 19470   
 
 19471   
 
 19472   
                     // AST REWRITE
 19473   
                     // elements: expression, LANGMATCHES
 19474   
                     // token labels:
 19475   
                     // rule labels: retval
 19476   
                     // token list labels:
 19477   
                     // rule list labels:
 19478   
                     // wildcard labels:
 19479  30 
                     retval.tree = root_0;
 19480  30 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19481   
 
 19482  30 
                     root_0 = (Object)adaptor.nil();
 19483   
                     // 547:70: -> ^( LANGMATCHES ( expression )+ )
 19484   
                     {
 19485   
                         // com\\googlecode\\sparkleg\\Sparql.g:547:73: ^( LANGMATCHES ( expression )+ )
 19486   
                         {
 19487  30 
                         Object root_1 = (Object)adaptor.nil();
 19488  30 
                         root_1 = (Object)adaptor.becomeRoot(
 19489   
                         stream_LANGMATCHES.nextNode()
 19490   
                         , root_1);
 19491   
 
 19492  30 
                         if ( !(stream_expression.hasNext()) ) {
 19493  0 
                             throw new RewriteEarlyExitException();
 19494   
                         }
 19495  90 
                         while ( stream_expression.hasNext() ) {
 19496  60 
                             adaptor.addChild(root_1, stream_expression.nextTree());
 19497   
 
 19498   
                         }
 19499  30 
                         stream_expression.reset();
 19500   
 
 19501  30 
                         adaptor.addChild(root_0, root_1);
 19502   
                         }
 19503   
 
 19504   
                     }
 19505   
 
 19506   
 
 19507  30 
                     retval.tree = root_0;
 19508   
 
 19509   
                     }
 19510  30 
                     break;
 19511   
                 case 4 :
 19512   
                     // com\\googlecode\\sparkleg\\Sparql.g:548:7: DATATYPE OPEN_BRACE expression CLOSE_BRACE
 19513   
                     {
 19514  100 
                     DATATYPE402=(Token)match(input,DATATYPE,FOLLOW_DATATYPE_in_builtInCall5120);
 19515  100 
                     stream_DATATYPE.add(DATATYPE402);
 19516   
 
 19517   
 
 19518  100 
                     OPEN_BRACE403=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5122);
 19519  100 
                     stream_OPEN_BRACE.add(OPEN_BRACE403);
 19520   
 
 19521   
 
 19522  100 
                     pushFollow(FOLLOW_expression_in_builtInCall5124);
 19523  100 
                     expression404=expression();
 19524   
 
 19525  100 
                     state._fsp--;
 19526   
 
 19527  100 
                     stream_expression.add(expression404.getTree());
 19528   
 
 19529  100 
                     CLOSE_BRACE405=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5126);
 19530  100 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE405);
 19531   
 
 19532   
 
 19533   
                     // AST REWRITE
 19534   
                     // elements: expression, DATATYPE
 19535   
                     // token labels:
 19536   
                     // rule labels: retval
 19537   
                     // token list labels:
 19538   
                     // rule list labels:
 19539   
                     // wildcard labels:
 19540  100 
                     retval.tree = root_0;
 19541  100 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19542   
 
 19543  100 
                     root_0 = (Object)adaptor.nil();
 19544   
                     // 548:50: -> ^( DATATYPE expression )
 19545   
                     {
 19546   
                         // com\\googlecode\\sparkleg\\Sparql.g:548:53: ^( DATATYPE expression )
 19547   
                         {
 19548  100 
                         Object root_1 = (Object)adaptor.nil();
 19549  100 
                         root_1 = (Object)adaptor.becomeRoot(
 19550   
                         stream_DATATYPE.nextNode()
 19551   
                         , root_1);
 19552   
 
 19553  100 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19554   
 
 19555  100 
                         adaptor.addChild(root_0, root_1);
 19556   
                         }
 19557   
 
 19558   
                     }
 19559   
 
 19560   
 
 19561  100 
                     retval.tree = root_0;
 19562   
 
 19563   
                     }
 19564  100 
                     break;
 19565   
                 case 5 :
 19566   
                     // com\\googlecode\\sparkleg\\Sparql.g:549:7: BOUND OPEN_BRACE var CLOSE_BRACE
 19567   
                     {
 19568  30 
                     BOUND406=(Token)match(input,BOUND,FOLLOW_BOUND_in_builtInCall5142);
 19569  30 
                     stream_BOUND.add(BOUND406);
 19570   
 
 19571   
 
 19572  30 
                     OPEN_BRACE407=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5144);
 19573  30 
                     stream_OPEN_BRACE.add(OPEN_BRACE407);
 19574   
 
 19575   
 
 19576  30 
                     pushFollow(FOLLOW_var_in_builtInCall5146);
 19577  30 
                     var408=var();
 19578   
 
 19579  30 
                     state._fsp--;
 19580   
 
 19581  30 
                     stream_var.add(var408.getTree());
 19582   
 
 19583  30 
                     CLOSE_BRACE409=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5148);
 19584  30 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE409);
 19585   
 
 19586   
 
 19587   
                     // AST REWRITE
 19588   
                     // elements: var, BOUND
 19589   
                     // token labels:
 19590   
                     // rule labels: retval
 19591   
                     // token list labels:
 19592   
                     // rule list labels:
 19593   
                     // wildcard labels:
 19594  30 
                     retval.tree = root_0;
 19595  30 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19596   
 
 19597  30 
                     root_0 = (Object)adaptor.nil();
 19598   
                     // 549:40: -> ^( BOUND var )
 19599   
                     {
 19600   
                         // com\\googlecode\\sparkleg\\Sparql.g:549:43: ^( BOUND var )
 19601   
                         {
 19602  30 
                         Object root_1 = (Object)adaptor.nil();
 19603  30 
                         root_1 = (Object)adaptor.becomeRoot(
 19604   
                         stream_BOUND.nextNode()
 19605   
                         , root_1);
 19606   
 
 19607  30 
                         adaptor.addChild(root_1, stream_var.nextTree());
 19608   
 
 19609  30 
                         adaptor.addChild(root_0, root_1);
 19610   
                         }
 19611   
 
 19612   
                     }
 19613   
 
 19614   
 
 19615  30 
                     retval.tree = root_0;
 19616   
 
 19617   
                     }
 19618  30 
                     break;
 19619   
                 case 6 :
 19620   
                     // com\\googlecode\\sparkleg\\Sparql.g:550:7: IRI OPEN_BRACE expression CLOSE_BRACE
 19621   
                     {
 19622  2 
                     IRI410=(Token)match(input,IRI,FOLLOW_IRI_in_builtInCall5164);
 19623  2 
                     stream_IRI.add(IRI410);
 19624   
 
 19625   
 
 19626  2 
                     OPEN_BRACE411=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5166);
 19627  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE411);
 19628   
 
 19629   
 
 19630  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5168);
 19631  2 
                     expression412=expression();
 19632   
 
 19633  2 
                     state._fsp--;
 19634   
 
 19635  2 
                     stream_expression.add(expression412.getTree());
 19636   
 
 19637  2 
                     CLOSE_BRACE413=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5170);
 19638  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE413);
 19639   
 
 19640   
 
 19641   
                     // AST REWRITE
 19642   
                     // elements: expression, IRI
 19643   
                     // token labels:
 19644   
                     // rule labels: retval
 19645   
                     // token list labels:
 19646   
                     // rule list labels:
 19647   
                     // wildcard labels:
 19648  2 
                     retval.tree = root_0;
 19649  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19650   
 
 19651  2 
                     root_0 = (Object)adaptor.nil();
 19652   
                     // 550:45: -> ^( IRI expression )
 19653   
                     {
 19654   
                         // com\\googlecode\\sparkleg\\Sparql.g:550:48: ^( IRI expression )
 19655   
                         {
 19656  2 
                         Object root_1 = (Object)adaptor.nil();
 19657  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19658   
                         stream_IRI.nextNode()
 19659   
                         , root_1);
 19660   
 
 19661  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19662   
 
 19663  2 
                         adaptor.addChild(root_0, root_1);
 19664   
                         }
 19665   
 
 19666   
                     }
 19667   
 
 19668   
 
 19669  2 
                     retval.tree = root_0;
 19670   
 
 19671   
                     }
 19672  2 
                     break;
 19673   
                 case 7 :
 19674   
                     // com\\googlecode\\sparkleg\\Sparql.g:551:7: URI OPEN_BRACE expression CLOSE_BRACE
 19675   
                     {
 19676  2 
                     URI414=(Token)match(input,URI,FOLLOW_URI_in_builtInCall5186);
 19677  2 
                     stream_URI.add(URI414);
 19678   
 
 19679   
 
 19680  2 
                     OPEN_BRACE415=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5188);
 19681  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE415);
 19682   
 
 19683   
 
 19684  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5190);
 19685  2 
                     expression416=expression();
 19686   
 
 19687  2 
                     state._fsp--;
 19688   
 
 19689  2 
                     stream_expression.add(expression416.getTree());
 19690   
 
 19691  2 
                     CLOSE_BRACE417=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5192);
 19692  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE417);
 19693   
 
 19694   
 
 19695   
                     // AST REWRITE
 19696   
                     // elements: expression, URI
 19697   
                     // token labels:
 19698   
                     // rule labels: retval
 19699   
                     // token list labels:
 19700   
                     // rule list labels:
 19701   
                     // wildcard labels:
 19702  2 
                     retval.tree = root_0;
 19703  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19704   
 
 19705  2 
                     root_0 = (Object)adaptor.nil();
 19706   
                     // 551:45: -> ^( URI expression )
 19707   
                     {
 19708   
                         // com\\googlecode\\sparkleg\\Sparql.g:551:48: ^( URI expression )
 19709   
                         {
 19710  2 
                         Object root_1 = (Object)adaptor.nil();
 19711  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19712   
                         stream_URI.nextNode()
 19713   
                         , root_1);
 19714   
 
 19715  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19716   
 
 19717  2 
                         adaptor.addChild(root_0, root_1);
 19718   
                         }
 19719   
 
 19720   
                     }
 19721   
 
 19722   
 
 19723  2 
                     retval.tree = root_0;
 19724   
 
 19725   
                     }
 19726  2 
                     break;
 19727   
                 case 8 :
 19728   
                     // com\\googlecode\\sparkleg\\Sparql.g:552:7: BNODE ( OPEN_BRACE expression CLOSE_BRACE )
 19729   
                     {
 19730  4 
                     BNODE418=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5208);
 19731  4 
                     stream_BNODE.add(BNODE418);
 19732   
 
 19733   
 
 19734   
                     // com\\googlecode\\sparkleg\\Sparql.g:552:13: ( OPEN_BRACE expression CLOSE_BRACE )
 19735   
                     // com\\googlecode\\sparkleg\\Sparql.g:552:14: OPEN_BRACE expression CLOSE_BRACE
 19736   
                     {
 19737  4 
                     OPEN_BRACE419=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5211);
 19738  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE419);
 19739   
 
 19740   
 
 19741  4 
                     pushFollow(FOLLOW_expression_in_builtInCall5213);
 19742  4 
                     expression420=expression();
 19743   
 
 19744  4 
                     state._fsp--;
 19745   
 
 19746  4 
                     stream_expression.add(expression420.getTree());
 19747   
 
 19748  4 
                     CLOSE_BRACE421=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5215);
 19749  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE421);
 19750   
 
 19751   
 
 19752   
                     }
 19753   
 
 19754   
 
 19755   
                     // AST REWRITE
 19756   
                     // elements: expression, BNODE
 19757   
                     // token labels:
 19758   
                     // rule labels: retval
 19759   
                     // token list labels:
 19760   
                     // rule list labels:
 19761   
                     // wildcard labels:
 19762  4 
                     retval.tree = root_0;
 19763  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19764   
 
 19765  4 
                     root_0 = (Object)adaptor.nil();
 19766   
                     // 552:49: -> ^( BNODE expression )
 19767   
                     {
 19768   
                         // com\\googlecode\\sparkleg\\Sparql.g:552:52: ^( BNODE expression )
 19769   
                         {
 19770  4 
                         Object root_1 = (Object)adaptor.nil();
 19771  4 
                         root_1 = (Object)adaptor.becomeRoot(
 19772   
                         stream_BNODE.nextNode()
 19773   
                         , root_1);
 19774   
 
 19775  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19776   
 
 19777  4 
                         adaptor.addChild(root_0, root_1);
 19778   
                         }
 19779   
 
 19780   
                     }
 19781   
 
 19782   
 
 19783  4 
                     retval.tree = root_0;
 19784   
 
 19785   
                     }
 19786  4 
                     break;
 19787   
                 case 9 :
 19788   
                     // com\\googlecode\\sparkleg\\Sparql.g:553:7: BNODE nil
 19789   
                     {
 19790  4 
                     BNODE422=(Token)match(input,BNODE,FOLLOW_BNODE_in_builtInCall5232);
 19791  4 
                     stream_BNODE.add(BNODE422);
 19792   
 
 19793   
 
 19794  4 
                     pushFollow(FOLLOW_nil_in_builtInCall5234);
 19795  4 
                     nil423=nil();
 19796   
 
 19797  4 
                     state._fsp--;
 19798   
 
 19799  4 
                     stream_nil.add(nil423.getTree());
 19800   
 
 19801   
                     // AST REWRITE
 19802   
                     // elements: BNODE
 19803   
                     // token labels:
 19804   
                     // rule labels: retval
 19805   
                     // token list labels:
 19806   
                     // rule list labels:
 19807   
                     // wildcard labels:
 19808  4 
                     retval.tree = root_0;
 19809  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19810   
 
 19811  4 
                     root_0 = (Object)adaptor.nil();
 19812   
                     // 553:17: -> BNODE
 19813   
                     {
 19814  4 
                         adaptor.addChild(root_0,
 19815   
                         stream_BNODE.nextNode()
 19816   
                         );
 19817   
 
 19818   
                     }
 19819   
 
 19820   
 
 19821  4 
                     retval.tree = root_0;
 19822   
 
 19823   
                     }
 19824  4 
                     break;
 19825   
                 case 10 :
 19826   
                     // com\\googlecode\\sparkleg\\Sparql.g:554:7: RAND nil
 19827   
                     {
 19828  2 
                     RAND424=(Token)match(input,RAND,FOLLOW_RAND_in_builtInCall5246);
 19829  2 
                     stream_RAND.add(RAND424);
 19830   
 
 19831   
 
 19832  2 
                     pushFollow(FOLLOW_nil_in_builtInCall5248);
 19833  2 
                     nil425=nil();
 19834   
 
 19835  2 
                     state._fsp--;
 19836   
 
 19837  2 
                     stream_nil.add(nil425.getTree());
 19838   
 
 19839   
                     // AST REWRITE
 19840   
                     // elements: RAND
 19841   
                     // token labels:
 19842   
                     // rule labels: retval
 19843   
                     // token list labels:
 19844   
                     // rule list labels:
 19845   
                     // wildcard labels:
 19846  2 
                     retval.tree = root_0;
 19847  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19848   
 
 19849  2 
                     root_0 = (Object)adaptor.nil();
 19850   
                     // 554:16: -> RAND
 19851   
                     {
 19852  2 
                         adaptor.addChild(root_0,
 19853   
                         stream_RAND.nextNode()
 19854   
                         );
 19855   
 
 19856   
                     }
 19857   
 
 19858   
 
 19859  2 
                     retval.tree = root_0;
 19860   
 
 19861   
                     }
 19862  2 
                     break;
 19863   
                 case 11 :
 19864   
                     // com\\googlecode\\sparkleg\\Sparql.g:555:7: ABS OPEN_BRACE expression CLOSE_BRACE
 19865   
                     {
 19866  2 
                     ABS426=(Token)match(input,ABS,FOLLOW_ABS_in_builtInCall5260);
 19867  2 
                     stream_ABS.add(ABS426);
 19868   
 
 19869   
 
 19870  2 
                     OPEN_BRACE427=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5262);
 19871  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE427);
 19872   
 
 19873   
 
 19874  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5264);
 19875  2 
                     expression428=expression();
 19876   
 
 19877  2 
                     state._fsp--;
 19878   
 
 19879  2 
                     stream_expression.add(expression428.getTree());
 19880   
 
 19881  2 
                     CLOSE_BRACE429=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5266);
 19882  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE429);
 19883   
 
 19884   
 
 19885   
                     // AST REWRITE
 19886   
                     // elements: expression, ABS
 19887   
                     // token labels:
 19888   
                     // rule labels: retval
 19889   
                     // token list labels:
 19890   
                     // rule list labels:
 19891   
                     // wildcard labels:
 19892  2 
                     retval.tree = root_0;
 19893  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19894   
 
 19895  2 
                     root_0 = (Object)adaptor.nil();
 19896   
                     // 555:45: -> ^( ABS expression )
 19897   
                     {
 19898   
                         // com\\googlecode\\sparkleg\\Sparql.g:555:48: ^( ABS expression )
 19899   
                         {
 19900  2 
                         Object root_1 = (Object)adaptor.nil();
 19901  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19902   
                         stream_ABS.nextNode()
 19903   
                         , root_1);
 19904   
 
 19905  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19906   
 
 19907  2 
                         adaptor.addChild(root_0, root_1);
 19908   
                         }
 19909   
 
 19910   
                     }
 19911   
 
 19912   
 
 19913  2 
                     retval.tree = root_0;
 19914   
 
 19915   
                     }
 19916  2 
                     break;
 19917   
                 case 12 :
 19918   
                     // com\\googlecode\\sparkleg\\Sparql.g:556:7: CEIL OPEN_BRACE expression CLOSE_BRACE
 19919   
                     {
 19920  2 
                     CEIL430=(Token)match(input,CEIL,FOLLOW_CEIL_in_builtInCall5282);
 19921  2 
                     stream_CEIL.add(CEIL430);
 19922   
 
 19923   
 
 19924  2 
                     OPEN_BRACE431=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5284);
 19925  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE431);
 19926   
 
 19927   
 
 19928  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5286);
 19929  2 
                     expression432=expression();
 19930   
 
 19931  2 
                     state._fsp--;
 19932   
 
 19933  2 
                     stream_expression.add(expression432.getTree());
 19934   
 
 19935  2 
                     CLOSE_BRACE433=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5288);
 19936  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE433);
 19937   
 
 19938   
 
 19939   
                     // AST REWRITE
 19940   
                     // elements: expression, CEIL
 19941   
                     // token labels:
 19942   
                     // rule labels: retval
 19943   
                     // token list labels:
 19944   
                     // rule list labels:
 19945   
                     // wildcard labels:
 19946  2 
                     retval.tree = root_0;
 19947  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 19948   
 
 19949  2 
                     root_0 = (Object)adaptor.nil();
 19950   
                     // 556:46: -> ^( CEIL expression )
 19951   
                     {
 19952   
                         // com\\googlecode\\sparkleg\\Sparql.g:556:49: ^( CEIL expression )
 19953   
                         {
 19954  2 
                         Object root_1 = (Object)adaptor.nil();
 19955  2 
                         root_1 = (Object)adaptor.becomeRoot(
 19956   
                         stream_CEIL.nextNode()
 19957   
                         , root_1);
 19958   
 
 19959  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 19960   
 
 19961  2 
                         adaptor.addChild(root_0, root_1);
 19962   
                         }
 19963   
 
 19964   
                     }
 19965   
 
 19966   
 
 19967  2 
                     retval.tree = root_0;
 19968   
 
 19969   
                     }
 19970  2 
                     break;
 19971   
                 case 13 :
 19972   
                     // com\\googlecode\\sparkleg\\Sparql.g:557:7: FLOOR OPEN_BRACE expression CLOSE_BRACE
 19973   
                     {
 19974  2 
                     FLOOR434=(Token)match(input,FLOOR,FOLLOW_FLOOR_in_builtInCall5304);
 19975  2 
                     stream_FLOOR.add(FLOOR434);
 19976   
 
 19977   
 
 19978  2 
                     OPEN_BRACE435=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5306);
 19979  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE435);
 19980   
 
 19981   
 
 19982  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5308);
 19983  2 
                     expression436=expression();
 19984   
 
 19985  2 
                     state._fsp--;
 19986   
 
 19987  2 
                     stream_expression.add(expression436.getTree());
 19988   
 
 19989  2 
                     CLOSE_BRACE437=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5310);
 19990  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE437);
 19991   
 
 19992   
 
 19993   
                     // AST REWRITE
 19994   
                     // elements: expression, FLOOR
 19995   
                     // token labels:
 19996   
                     // rule labels: retval
 19997   
                     // token list labels:
 19998   
                     // rule list labels:
 19999   
                     // wildcard labels:
 20000  2 
                     retval.tree = root_0;
 20001  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20002   
 
 20003  2 
                     root_0 = (Object)adaptor.nil();
 20004   
                     // 557:47: -> ^( FLOOR expression )
 20005   
                     {
 20006   
                         // com\\googlecode\\sparkleg\\Sparql.g:557:50: ^( FLOOR expression )
 20007   
                         {
 20008  2 
                         Object root_1 = (Object)adaptor.nil();
 20009  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20010   
                         stream_FLOOR.nextNode()
 20011   
                         , root_1);
 20012   
 
 20013  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20014   
 
 20015  2 
                         adaptor.addChild(root_0, root_1);
 20016   
                         }
 20017   
 
 20018   
                     }
 20019   
 
 20020   
 
 20021  2 
                     retval.tree = root_0;
 20022   
 
 20023   
                     }
 20024  2 
                     break;
 20025   
                 case 14 :
 20026   
                     // com\\googlecode\\sparkleg\\Sparql.g:558:7: ROUND OPEN_BRACE expression CLOSE_BRACE
 20027   
                     {
 20028  2 
                     ROUND438=(Token)match(input,ROUND,FOLLOW_ROUND_in_builtInCall5326);
 20029  2 
                     stream_ROUND.add(ROUND438);
 20030   
 
 20031   
 
 20032  2 
                     OPEN_BRACE439=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5328);
 20033  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE439);
 20034   
 
 20035   
 
 20036  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5330);
 20037  2 
                     expression440=expression();
 20038   
 
 20039  2 
                     state._fsp--;
 20040   
 
 20041  2 
                     stream_expression.add(expression440.getTree());
 20042   
 
 20043  2 
                     CLOSE_BRACE441=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5332);
 20044  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE441);
 20045   
 
 20046   
 
 20047   
                     // AST REWRITE
 20048   
                     // elements: ROUND, expression
 20049   
                     // token labels:
 20050   
                     // rule labels: retval
 20051   
                     // token list labels:
 20052   
                     // rule list labels:
 20053   
                     // wildcard labels:
 20054  2 
                     retval.tree = root_0;
 20055  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20056   
 
 20057  2 
                     root_0 = (Object)adaptor.nil();
 20058   
                     // 558:47: -> ^( ROUND expression )
 20059   
                     {
 20060   
                         // com\\googlecode\\sparkleg\\Sparql.g:558:50: ^( ROUND expression )
 20061   
                         {
 20062  2 
                         Object root_1 = (Object)adaptor.nil();
 20063  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20064   
                         stream_ROUND.nextNode()
 20065   
                         , root_1);
 20066   
 
 20067  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20068   
 
 20069  2 
                         adaptor.addChild(root_0, root_1);
 20070   
                         }
 20071   
 
 20072   
                     }
 20073   
 
 20074   
 
 20075  2 
                     retval.tree = root_0;
 20076   
 
 20077   
                     }
 20078  2 
                     break;
 20079   
                 case 15 :
 20080   
                     // com\\googlecode\\sparkleg\\Sparql.g:559:7: CONCAT expressionList
 20081   
                     {
 20082  10 
                     CONCAT442=(Token)match(input,CONCAT,FOLLOW_CONCAT_in_builtInCall5348);
 20083  10 
                     stream_CONCAT.add(CONCAT442);
 20084   
 
 20085   
 
 20086  10 
                     pushFollow(FOLLOW_expressionList_in_builtInCall5350);
 20087  10 
                     expressionList443=expressionList();
 20088   
 
 20089  10 
                     state._fsp--;
 20090   
 
 20091  10 
                     stream_expressionList.add(expressionList443.getTree());
 20092   
 
 20093   
                     // AST REWRITE
 20094   
                     // elements: expressionList, CONCAT
 20095   
                     // token labels:
 20096   
                     // rule labels: retval
 20097   
                     // token list labels:
 20098   
                     // rule list labels:
 20099   
                     // wildcard labels:
 20100  10 
                     retval.tree = root_0;
 20101  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20102   
 
 20103  10 
                     root_0 = (Object)adaptor.nil();
 20104   
                     // 559:29: -> ^( CONCAT expressionList )
 20105   
                     {
 20106   
                         // com\\googlecode\\sparkleg\\Sparql.g:559:32: ^( CONCAT expressionList )
 20107   
                         {
 20108  10 
                         Object root_1 = (Object)adaptor.nil();
 20109  10 
                         root_1 = (Object)adaptor.becomeRoot(
 20110   
                         stream_CONCAT.nextNode()
 20111   
                         , root_1);
 20112   
 
 20113  10 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 20114   
 
 20115  10 
                         adaptor.addChild(root_0, root_1);
 20116   
                         }
 20117   
 
 20118   
                     }
 20119   
 
 20120   
 
 20121  10 
                     retval.tree = root_0;
 20122   
 
 20123   
                     }
 20124  10 
                     break;
 20125   
                 case 16 :
 20126   
                     // com\\googlecode\\sparkleg\\Sparql.g:560:7: subStringExpression
 20127   
                     {
 20128  4 
                     pushFollow(FOLLOW_subStringExpression_in_builtInCall5366);
 20129  4 
                     subStringExpression444=subStringExpression();
 20130   
 
 20131  4 
                     state._fsp--;
 20132   
 
 20133  4 
                     stream_subStringExpression.add(subStringExpression444.getTree());
 20134   
 
 20135   
                     // AST REWRITE
 20136   
                     // elements: subStringExpression
 20137   
                     // token labels:
 20138   
                     // rule labels: retval
 20139   
                     // token list labels:
 20140   
                     // rule list labels:
 20141   
                     // wildcard labels:
 20142  4 
                     retval.tree = root_0;
 20143  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20144   
 
 20145  4 
                     root_0 = (Object)adaptor.nil();
 20146   
                     // 560:27: -> subStringExpression
 20147   
                     {
 20148  4 
                         adaptor.addChild(root_0, stream_subStringExpression.nextTree());
 20149   
 
 20150   
                     }
 20151   
 
 20152   
 
 20153  4 
                     retval.tree = root_0;
 20154   
 
 20155   
                     }
 20156  4 
                     break;
 20157   
                 case 17 :
 20158   
                     // com\\googlecode\\sparkleg\\Sparql.g:561:7: STRLEN OPEN_BRACE expression CLOSE_BRACE
 20159   
                     {
 20160  2 
                     STRLEN445=(Token)match(input,STRLEN,FOLLOW_STRLEN_in_builtInCall5378);
 20161  2 
                     stream_STRLEN.add(STRLEN445);
 20162   
 
 20163   
 
 20164  2 
                     OPEN_BRACE446=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5380);
 20165  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE446);
 20166   
 
 20167   
 
 20168  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5382);
 20169  2 
                     expression447=expression();
 20170   
 
 20171  2 
                     state._fsp--;
 20172   
 
 20173  2 
                     stream_expression.add(expression447.getTree());
 20174   
 
 20175  2 
                     CLOSE_BRACE448=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5384);
 20176  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE448);
 20177   
 
 20178   
 
 20179   
                     // AST REWRITE
 20180   
                     // elements: expression, STRLEN
 20181   
                     // token labels:
 20182   
                     // rule labels: retval
 20183   
                     // token list labels:
 20184   
                     // rule list labels:
 20185   
                     // wildcard labels:
 20186  2 
                     retval.tree = root_0;
 20187  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20188   
 
 20189  2 
                     root_0 = (Object)adaptor.nil();
 20190   
                     // 561:48: -> ^( STRLEN expression )
 20191   
                     {
 20192   
                         // com\\googlecode\\sparkleg\\Sparql.g:561:51: ^( STRLEN expression )
 20193   
                         {
 20194  2 
                         Object root_1 = (Object)adaptor.nil();
 20195  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20196   
                         stream_STRLEN.nextNode()
 20197   
                         , root_1);
 20198   
 
 20199  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20200   
 
 20201  2 
                         adaptor.addChild(root_0, root_1);
 20202   
                         }
 20203   
 
 20204   
                     }
 20205   
 
 20206   
 
 20207  2 
                     retval.tree = root_0;
 20208   
 
 20209   
                     }
 20210  2 
                     break;
 20211   
                 case 18 :
 20212   
                     // com\\googlecode\\sparkleg\\Sparql.g:562:7: UCASE OPEN_BRACE expression CLOSE_BRACE
 20213   
                     {
 20214  2 
                     UCASE449=(Token)match(input,UCASE,FOLLOW_UCASE_in_builtInCall5400);
 20215  2 
                     stream_UCASE.add(UCASE449);
 20216   
 
 20217   
 
 20218  2 
                     OPEN_BRACE450=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5402);
 20219  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE450);
 20220   
 
 20221   
 
 20222  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5404);
 20223  2 
                     expression451=expression();
 20224   
 
 20225  2 
                     state._fsp--;
 20226   
 
 20227  2 
                     stream_expression.add(expression451.getTree());
 20228   
 
 20229  2 
                     CLOSE_BRACE452=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5406);
 20230  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE452);
 20231   
 
 20232   
 
 20233   
                     // AST REWRITE
 20234   
                     // elements: expression, UCASE
 20235   
                     // token labels:
 20236   
                     // rule labels: retval
 20237   
                     // token list labels:
 20238   
                     // rule list labels:
 20239   
                     // wildcard labels:
 20240  2 
                     retval.tree = root_0;
 20241  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20242   
 
 20243  2 
                     root_0 = (Object)adaptor.nil();
 20244   
                     // 562:47: -> ^( UCASE expression )
 20245   
                     {
 20246   
                         // com\\googlecode\\sparkleg\\Sparql.g:562:50: ^( UCASE expression )
 20247   
                         {
 20248  2 
                         Object root_1 = (Object)adaptor.nil();
 20249  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20250   
                         stream_UCASE.nextNode()
 20251   
                         , root_1);
 20252   
 
 20253  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20254   
 
 20255  2 
                         adaptor.addChild(root_0, root_1);
 20256   
                         }
 20257   
 
 20258   
                     }
 20259   
 
 20260   
 
 20261  2 
                     retval.tree = root_0;
 20262   
 
 20263   
                     }
 20264  2 
                     break;
 20265   
                 case 19 :
 20266   
                     // com\\googlecode\\sparkleg\\Sparql.g:563:7: LCASE OPEN_BRACE expression CLOSE_BRACE
 20267   
                     {
 20268  2 
                     LCASE453=(Token)match(input,LCASE,FOLLOW_LCASE_in_builtInCall5422);
 20269  2 
                     stream_LCASE.add(LCASE453);
 20270   
 
 20271   
 
 20272  2 
                     OPEN_BRACE454=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5424);
 20273  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE454);
 20274   
 
 20275   
 
 20276  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5426);
 20277  2 
                     expression455=expression();
 20278   
 
 20279  2 
                     state._fsp--;
 20280   
 
 20281  2 
                     stream_expression.add(expression455.getTree());
 20282   
 
 20283  2 
                     CLOSE_BRACE456=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5428);
 20284  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE456);
 20285   
 
 20286   
 
 20287   
                     // AST REWRITE
 20288   
                     // elements: expression, LCASE
 20289   
                     // token labels:
 20290   
                     // rule labels: retval
 20291   
                     // token list labels:
 20292   
                     // rule list labels:
 20293   
                     // wildcard labels:
 20294  2 
                     retval.tree = root_0;
 20295  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20296   
 
 20297  2 
                     root_0 = (Object)adaptor.nil();
 20298   
                     // 563:47: -> ^( LCASE expression )
 20299   
                     {
 20300   
                         // com\\googlecode\\sparkleg\\Sparql.g:563:50: ^( LCASE expression )
 20301   
                         {
 20302  2 
                         Object root_1 = (Object)adaptor.nil();
 20303  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20304   
                         stream_LCASE.nextNode()
 20305   
                         , root_1);
 20306   
 
 20307  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20308   
 
 20309  2 
                         adaptor.addChild(root_0, root_1);
 20310   
                         }
 20311   
 
 20312   
                     }
 20313   
 
 20314   
 
 20315  2 
                     retval.tree = root_0;
 20316   
 
 20317   
                     }
 20318  2 
                     break;
 20319   
                 case 20 :
 20320   
                     // com\\googlecode\\sparkleg\\Sparql.g:564:7: ENCODE_FOR_URI OPEN_BRACE expression CLOSE_BRACE
 20321   
                     {
 20322  2 
                     ENCODE_FOR_URI457=(Token)match(input,ENCODE_FOR_URI,FOLLOW_ENCODE_FOR_URI_in_builtInCall5444);
 20323  2 
                     stream_ENCODE_FOR_URI.add(ENCODE_FOR_URI457);
 20324   
 
 20325   
 
 20326  2 
                     OPEN_BRACE458=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5446);
 20327  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE458);
 20328   
 
 20329   
 
 20330  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5448);
 20331  2 
                     expression459=expression();
 20332   
 
 20333  2 
                     state._fsp--;
 20334   
 
 20335  2 
                     stream_expression.add(expression459.getTree());
 20336   
 
 20337  2 
                     CLOSE_BRACE460=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5450);
 20338  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE460);
 20339   
 
 20340   
 
 20341   
                     // AST REWRITE
 20342   
                     // elements: ENCODE_FOR_URI, expression
 20343   
                     // token labels:
 20344   
                     // rule labels: retval
 20345   
                     // token list labels:
 20346   
                     // rule list labels:
 20347   
                     // wildcard labels:
 20348  2 
                     retval.tree = root_0;
 20349  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20350   
 
 20351  2 
                     root_0 = (Object)adaptor.nil();
 20352   
                     // 564:56: -> ^( ENCODE_FOR_URI expression )
 20353   
                     {
 20354   
                         // com\\googlecode\\sparkleg\\Sparql.g:564:59: ^( ENCODE_FOR_URI expression )
 20355   
                         {
 20356  2 
                         Object root_1 = (Object)adaptor.nil();
 20357  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20358   
                         stream_ENCODE_FOR_URI.nextNode()
 20359   
                         , root_1);
 20360   
 
 20361  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20362   
 
 20363  2 
                         adaptor.addChild(root_0, root_1);
 20364   
                         }
 20365   
 
 20366   
                     }
 20367   
 
 20368   
 
 20369  2 
                     retval.tree = root_0;
 20370   
 
 20371   
                     }
 20372  2 
                     break;
 20373   
                 case 21 :
 20374   
                     // com\\googlecode\\sparkleg\\Sparql.g:565:7: CONTAINS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20375   
                     {
 20376  2 
                     CONTAINS461=(Token)match(input,CONTAINS,FOLLOW_CONTAINS_in_builtInCall5466);
 20377  2 
                     stream_CONTAINS.add(CONTAINS461);
 20378   
 
 20379   
 
 20380  2 
                     OPEN_BRACE462=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5468);
 20381  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE462);
 20382   
 
 20383   
 
 20384  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5470);
 20385  2 
                     expression463=expression();
 20386   
 
 20387  2 
                     state._fsp--;
 20388   
 
 20389  2 
                     stream_expression.add(expression463.getTree());
 20390   
 
 20391  2 
                     COMMA464=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5472);
 20392  2 
                     stream_COMMA.add(COMMA464);
 20393   
 
 20394   
 
 20395  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5474);
 20396  2 
                     expression465=expression();
 20397   
 
 20398  2 
                     state._fsp--;
 20399   
 
 20400  2 
                     stream_expression.add(expression465.getTree());
 20401   
 
 20402  2 
                     CLOSE_BRACE466=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5476);
 20403  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE466);
 20404   
 
 20405   
 
 20406   
                     // AST REWRITE
 20407   
                     // elements: expression, expression, CONTAINS
 20408   
                     // token labels:
 20409   
                     // rule labels: retval
 20410   
                     // token list labels:
 20411   
                     // rule list labels:
 20412   
                     // wildcard labels:
 20413  2 
                     retval.tree = root_0;
 20414  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20415   
 
 20416  2 
                     root_0 = (Object)adaptor.nil();
 20417   
                     // 565:67: -> ^( CONTAINS expression expression )
 20418   
                     {
 20419   
                         // com\\googlecode\\sparkleg\\Sparql.g:565:70: ^( CONTAINS expression expression )
 20420   
                         {
 20421  2 
                         Object root_1 = (Object)adaptor.nil();
 20422  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20423   
                         stream_CONTAINS.nextNode()
 20424   
                         , root_1);
 20425   
 
 20426  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20427   
 
 20428  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20429   
 
 20430  2 
                         adaptor.addChild(root_0, root_1);
 20431   
                         }
 20432   
 
 20433   
                     }
 20434   
 
 20435   
 
 20436  2 
                     retval.tree = root_0;
 20437   
 
 20438   
                     }
 20439  2 
                     break;
 20440   
                 case 22 :
 20441   
                     // com\\googlecode\\sparkleg\\Sparql.g:566:7: STRSTARTS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20442   
                     {
 20443  2 
                     STRSTARTS467=(Token)match(input,STRSTARTS,FOLLOW_STRSTARTS_in_builtInCall5494);
 20444  2 
                     stream_STRSTARTS.add(STRSTARTS467);
 20445   
 
 20446   
 
 20447  2 
                     OPEN_BRACE468=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5496);
 20448  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE468);
 20449   
 
 20450   
 
 20451  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5498);
 20452  2 
                     expression469=expression();
 20453   
 
 20454  2 
                     state._fsp--;
 20455   
 
 20456  2 
                     stream_expression.add(expression469.getTree());
 20457   
 
 20458  2 
                     COMMA470=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5500);
 20459  2 
                     stream_COMMA.add(COMMA470);
 20460   
 
 20461   
 
 20462  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5502);
 20463  2 
                     expression471=expression();
 20464   
 
 20465  2 
                     state._fsp--;
 20466   
 
 20467  2 
                     stream_expression.add(expression471.getTree());
 20468   
 
 20469  2 
                     CLOSE_BRACE472=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5504);
 20470  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE472);
 20471   
 
 20472   
 
 20473   
                     // AST REWRITE
 20474   
                     // elements: expression, expression, STRSTARTS
 20475   
                     // token labels:
 20476   
                     // rule labels: retval
 20477   
                     // token list labels:
 20478   
                     // rule list labels:
 20479   
                     // wildcard labels:
 20480  2 
                     retval.tree = root_0;
 20481  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20482   
 
 20483  2 
                     root_0 = (Object)adaptor.nil();
 20484   
                     // 566:68: -> ^( STRSTARTS expression expression )
 20485   
                     {
 20486   
                         // com\\googlecode\\sparkleg\\Sparql.g:566:71: ^( STRSTARTS expression expression )
 20487   
                         {
 20488  2 
                         Object root_1 = (Object)adaptor.nil();
 20489  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20490   
                         stream_STRSTARTS.nextNode()
 20491   
                         , root_1);
 20492   
 
 20493  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20494   
 
 20495  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20496   
 
 20497  2 
                         adaptor.addChild(root_0, root_1);
 20498   
                         }
 20499   
 
 20500   
                     }
 20501   
 
 20502   
 
 20503  2 
                     retval.tree = root_0;
 20504   
 
 20505   
                     }
 20506  2 
                     break;
 20507   
                 case 23 :
 20508   
                     // com\\googlecode\\sparkleg\\Sparql.g:567:7: STRENDS OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20509   
                     {
 20510  2 
                     STRENDS473=(Token)match(input,STRENDS,FOLLOW_STRENDS_in_builtInCall5522);
 20511  2 
                     stream_STRENDS.add(STRENDS473);
 20512   
 
 20513   
 
 20514  2 
                     OPEN_BRACE474=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5524);
 20515  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE474);
 20516   
 
 20517   
 
 20518  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5526);
 20519  2 
                     expression475=expression();
 20520   
 
 20521  2 
                     state._fsp--;
 20522   
 
 20523  2 
                     stream_expression.add(expression475.getTree());
 20524   
 
 20525  2 
                     COMMA476=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5528);
 20526  2 
                     stream_COMMA.add(COMMA476);
 20527   
 
 20528   
 
 20529  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5530);
 20530  2 
                     expression477=expression();
 20531   
 
 20532  2 
                     state._fsp--;
 20533   
 
 20534  2 
                     stream_expression.add(expression477.getTree());
 20535   
 
 20536  2 
                     CLOSE_BRACE478=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5532);
 20537  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE478);
 20538   
 
 20539   
 
 20540   
                     // AST REWRITE
 20541   
                     // elements: expression, STRENDS, expression
 20542   
                     // token labels:
 20543   
                     // rule labels: retval
 20544   
                     // token list labels:
 20545   
                     // rule list labels:
 20546   
                     // wildcard labels:
 20547  2 
                     retval.tree = root_0;
 20548  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20549   
 
 20550  2 
                     root_0 = (Object)adaptor.nil();
 20551   
                     // 567:66: -> ^( STRENDS expression expression )
 20552   
                     {
 20553   
                         // com\\googlecode\\sparkleg\\Sparql.g:567:69: ^( STRENDS expression expression )
 20554   
                         {
 20555  2 
                         Object root_1 = (Object)adaptor.nil();
 20556  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20557   
                         stream_STRENDS.nextNode()
 20558   
                         , root_1);
 20559   
 
 20560  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20561   
 
 20562  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20563   
 
 20564  2 
                         adaptor.addChild(root_0, root_1);
 20565   
                         }
 20566   
 
 20567   
                     }
 20568   
 
 20569   
 
 20570  2 
                     retval.tree = root_0;
 20571   
 
 20572   
                     }
 20573  2 
                     break;
 20574   
                 case 24 :
 20575   
                     // com\\googlecode\\sparkleg\\Sparql.g:568:7: STRBEFORE OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20576   
                     {
 20577  2 
                     STRBEFORE479=(Token)match(input,STRBEFORE,FOLLOW_STRBEFORE_in_builtInCall5550);
 20578  2 
                     stream_STRBEFORE.add(STRBEFORE479);
 20579   
 
 20580   
 
 20581  2 
                     OPEN_BRACE480=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5552);
 20582  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE480);
 20583   
 
 20584   
 
 20585  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5554);
 20586  2 
                     expression481=expression();
 20587   
 
 20588  2 
                     state._fsp--;
 20589   
 
 20590  2 
                     stream_expression.add(expression481.getTree());
 20591   
 
 20592  2 
                     COMMA482=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5556);
 20593  2 
                     stream_COMMA.add(COMMA482);
 20594   
 
 20595   
 
 20596  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5558);
 20597  2 
                     expression483=expression();
 20598   
 
 20599  2 
                     state._fsp--;
 20600   
 
 20601  2 
                     stream_expression.add(expression483.getTree());
 20602   
 
 20603  2 
                     CLOSE_BRACE484=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5560);
 20604  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE484);
 20605   
 
 20606   
 
 20607   
                     // AST REWRITE
 20608   
                     // elements: STRBEFORE, expression, expression
 20609   
                     // token labels:
 20610   
                     // rule labels: retval
 20611   
                     // token list labels:
 20612   
                     // rule list labels:
 20613   
                     // wildcard labels:
 20614  2 
                     retval.tree = root_0;
 20615  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20616   
 
 20617  2 
                     root_0 = (Object)adaptor.nil();
 20618   
                     // 568:68: -> ^( STRBEFORE expression expression )
 20619   
                     {
 20620   
                         // com\\googlecode\\sparkleg\\Sparql.g:568:71: ^( STRBEFORE expression expression )
 20621   
                         {
 20622  2 
                         Object root_1 = (Object)adaptor.nil();
 20623  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20624   
                         stream_STRBEFORE.nextNode()
 20625   
                         , root_1);
 20626   
 
 20627  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20628   
 
 20629  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20630   
 
 20631  2 
                         adaptor.addChild(root_0, root_1);
 20632   
                         }
 20633   
 
 20634   
                     }
 20635   
 
 20636   
 
 20637  2 
                     retval.tree = root_0;
 20638   
 
 20639   
                     }
 20640  2 
                     break;
 20641   
                 case 25 :
 20642   
                     // com\\googlecode\\sparkleg\\Sparql.g:569:7: STRAFTER OPEN_BRACE expression COMMA expression CLOSE_BRACE
 20643   
                     {
 20644  2 
                     STRAFTER485=(Token)match(input,STRAFTER,FOLLOW_STRAFTER_in_builtInCall5578);
 20645  2 
                     stream_STRAFTER.add(STRAFTER485);
 20646   
 
 20647   
 
 20648  2 
                     OPEN_BRACE486=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5580);
 20649  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE486);
 20650   
 
 20651   
 
 20652  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5582);
 20653  2 
                     expression487=expression();
 20654   
 
 20655  2 
                     state._fsp--;
 20656   
 
 20657  2 
                     stream_expression.add(expression487.getTree());
 20658   
 
 20659  2 
                     COMMA488=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5584);
 20660  2 
                     stream_COMMA.add(COMMA488);
 20661   
 
 20662   
 
 20663  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5586);
 20664  2 
                     expression489=expression();
 20665   
 
 20666  2 
                     state._fsp--;
 20667   
 
 20668  2 
                     stream_expression.add(expression489.getTree());
 20669   
 
 20670  2 
                     CLOSE_BRACE490=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5588);
 20671  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE490);
 20672   
 
 20673   
 
 20674   
                     // AST REWRITE
 20675   
                     // elements: expression, STRAFTER, expression
 20676   
                     // token labels:
 20677   
                     // rule labels: retval
 20678   
                     // token list labels:
 20679   
                     // rule list labels:
 20680   
                     // wildcard labels:
 20681  2 
                     retval.tree = root_0;
 20682  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20683   
 
 20684  2 
                     root_0 = (Object)adaptor.nil();
 20685   
                     // 569:67: -> ^( STRAFTER expression expression )
 20686   
                     {
 20687   
                         // com\\googlecode\\sparkleg\\Sparql.g:569:70: ^( STRAFTER expression expression )
 20688   
                         {
 20689  2 
                         Object root_1 = (Object)adaptor.nil();
 20690  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20691   
                         stream_STRAFTER.nextNode()
 20692   
                         , root_1);
 20693   
 
 20694  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20695   
 
 20696  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20697   
 
 20698  2 
                         adaptor.addChild(root_0, root_1);
 20699   
                         }
 20700   
 
 20701   
                     }
 20702   
 
 20703   
 
 20704  2 
                     retval.tree = root_0;
 20705   
 
 20706   
                     }
 20707  2 
                     break;
 20708   
                 case 26 :
 20709   
                     // com\\googlecode\\sparkleg\\Sparql.g:570:7: REPLACE OPEN_BRACE expression COMMA expression COMMA expression CLOSE_BRACE
 20710   
                     {
 20711  6 
                     REPLACE491=(Token)match(input,REPLACE,FOLLOW_REPLACE_in_builtInCall5606);
 20712  6 
                     stream_REPLACE.add(REPLACE491);
 20713   
 
 20714   
 
 20715  6 
                     OPEN_BRACE492=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5608);
 20716  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE492);
 20717   
 
 20718   
 
 20719  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5610);
 20720  6 
                     expression493=expression();
 20721   
 
 20722  6 
                     state._fsp--;
 20723   
 
 20724  6 
                     stream_expression.add(expression493.getTree());
 20725   
 
 20726  6 
                     COMMA494=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5612);
 20727  6 
                     stream_COMMA.add(COMMA494);
 20728   
 
 20729   
 
 20730  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5614);
 20731  6 
                     expression495=expression();
 20732   
 
 20733  6 
                     state._fsp--;
 20734   
 
 20735  6 
                     stream_expression.add(expression495.getTree());
 20736   
 
 20737  6 
                     COMMA496=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5616);
 20738  6 
                     stream_COMMA.add(COMMA496);
 20739   
 
 20740   
 
 20741  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5618);
 20742  6 
                     expression497=expression();
 20743   
 
 20744  6 
                     state._fsp--;
 20745   
 
 20746  6 
                     stream_expression.add(expression497.getTree());
 20747   
 
 20748  6 
                     CLOSE_BRACE498=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5620);
 20749  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE498);
 20750   
 
 20751   
 
 20752   
                     // AST REWRITE
 20753   
                     // elements: expression, expression, REPLACE, expression
 20754   
                     // token labels:
 20755   
                     // rule labels: retval
 20756   
                     // token list labels:
 20757   
                     // rule list labels:
 20758   
                     // wildcard labels:
 20759  6 
                     retval.tree = root_0;
 20760  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20761   
 
 20762  6 
                     root_0 = (Object)adaptor.nil();
 20763   
                     // 570:83: -> ^( REPLACE expression expression expression )
 20764   
                     {
 20765   
                         // com\\googlecode\\sparkleg\\Sparql.g:570:86: ^( REPLACE expression expression expression )
 20766   
                         {
 20767  6 
                         Object root_1 = (Object)adaptor.nil();
 20768  6 
                         root_1 = (Object)adaptor.becomeRoot(
 20769   
                         stream_REPLACE.nextNode()
 20770   
                         , root_1);
 20771   
 
 20772  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20773   
 
 20774  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20775   
 
 20776  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20777   
 
 20778  6 
                         adaptor.addChild(root_0, root_1);
 20779   
                         }
 20780   
 
 20781   
                     }
 20782   
 
 20783   
 
 20784  6 
                     retval.tree = root_0;
 20785   
 
 20786   
                     }
 20787  6 
                     break;
 20788   
                 case 27 :
 20789   
                     // com\\googlecode\\sparkleg\\Sparql.g:571:7: YEAR OPEN_BRACE expression CLOSE_BRACE
 20790   
                     {
 20791  2 
                     YEAR499=(Token)match(input,YEAR,FOLLOW_YEAR_in_builtInCall5640);
 20792  2 
                     stream_YEAR.add(YEAR499);
 20793   
 
 20794   
 
 20795  2 
                     OPEN_BRACE500=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5642);
 20796  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE500);
 20797   
 
 20798   
 
 20799  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5644);
 20800  2 
                     expression501=expression();
 20801   
 
 20802  2 
                     state._fsp--;
 20803   
 
 20804  2 
                     stream_expression.add(expression501.getTree());
 20805   
 
 20806  2 
                     CLOSE_BRACE502=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5646);
 20807  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE502);
 20808   
 
 20809   
 
 20810   
                     // AST REWRITE
 20811   
                     // elements: expression, YEAR
 20812   
                     // token labels:
 20813   
                     // rule labels: retval
 20814   
                     // token list labels:
 20815   
                     // rule list labels:
 20816   
                     // wildcard labels:
 20817  2 
                     retval.tree = root_0;
 20818  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20819   
 
 20820  2 
                     root_0 = (Object)adaptor.nil();
 20821   
                     // 571:46: -> ^( YEAR expression )
 20822   
                     {
 20823   
                         // com\\googlecode\\sparkleg\\Sparql.g:571:49: ^( YEAR expression )
 20824   
                         {
 20825  2 
                         Object root_1 = (Object)adaptor.nil();
 20826  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20827   
                         stream_YEAR.nextNode()
 20828   
                         , root_1);
 20829   
 
 20830  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20831   
 
 20832  2 
                         adaptor.addChild(root_0, root_1);
 20833   
                         }
 20834   
 
 20835   
                     }
 20836   
 
 20837   
 
 20838  2 
                     retval.tree = root_0;
 20839   
 
 20840   
                     }
 20841  2 
                     break;
 20842   
                 case 28 :
 20843   
                     // com\\googlecode\\sparkleg\\Sparql.g:572:7: MONTH OPEN_BRACE expression CLOSE_BRACE
 20844   
                     {
 20845  2 
                     MONTH503=(Token)match(input,MONTH,FOLLOW_MONTH_in_builtInCall5662);
 20846  2 
                     stream_MONTH.add(MONTH503);
 20847   
 
 20848   
 
 20849  2 
                     OPEN_BRACE504=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5664);
 20850  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE504);
 20851   
 
 20852   
 
 20853  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5666);
 20854  2 
                     expression505=expression();
 20855   
 
 20856  2 
                     state._fsp--;
 20857   
 
 20858  2 
                     stream_expression.add(expression505.getTree());
 20859   
 
 20860  2 
                     CLOSE_BRACE506=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5668);
 20861  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE506);
 20862   
 
 20863   
 
 20864   
                     // AST REWRITE
 20865   
                     // elements: expression, MONTH
 20866   
                     // token labels:
 20867   
                     // rule labels: retval
 20868   
                     // token list labels:
 20869   
                     // rule list labels:
 20870   
                     // wildcard labels:
 20871  2 
                     retval.tree = root_0;
 20872  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20873   
 
 20874  2 
                     root_0 = (Object)adaptor.nil();
 20875   
                     // 572:47: -> ^( MONTH expression )
 20876   
                     {
 20877   
                         // com\\googlecode\\sparkleg\\Sparql.g:572:50: ^( MONTH expression )
 20878   
                         {
 20879  2 
                         Object root_1 = (Object)adaptor.nil();
 20880  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20881   
                         stream_MONTH.nextNode()
 20882   
                         , root_1);
 20883   
 
 20884  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20885   
 
 20886  2 
                         adaptor.addChild(root_0, root_1);
 20887   
                         }
 20888   
 
 20889   
                     }
 20890   
 
 20891   
 
 20892  2 
                     retval.tree = root_0;
 20893   
 
 20894   
                     }
 20895  2 
                     break;
 20896   
                 case 29 :
 20897   
                     // com\\googlecode\\sparkleg\\Sparql.g:573:7: DAY OPEN_BRACE expression CLOSE_BRACE
 20898   
                     {
 20899  2 
                     DAY507=(Token)match(input,DAY,FOLLOW_DAY_in_builtInCall5684);
 20900  2 
                     stream_DAY.add(DAY507);
 20901   
 
 20902   
 
 20903  2 
                     OPEN_BRACE508=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5686);
 20904  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE508);
 20905   
 
 20906   
 
 20907  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5688);
 20908  2 
                     expression509=expression();
 20909   
 
 20910  2 
                     state._fsp--;
 20911   
 
 20912  2 
                     stream_expression.add(expression509.getTree());
 20913   
 
 20914  2 
                     CLOSE_BRACE510=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5690);
 20915  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE510);
 20916   
 
 20917   
 
 20918   
                     // AST REWRITE
 20919   
                     // elements: expression, DAY
 20920   
                     // token labels:
 20921   
                     // rule labels: retval
 20922   
                     // token list labels:
 20923   
                     // rule list labels:
 20924   
                     // wildcard labels:
 20925  2 
                     retval.tree = root_0;
 20926  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20927   
 
 20928  2 
                     root_0 = (Object)adaptor.nil();
 20929   
                     // 573:45: -> ^( DAY expression )
 20930   
                     {
 20931   
                         // com\\googlecode\\sparkleg\\Sparql.g:573:48: ^( DAY expression )
 20932   
                         {
 20933  2 
                         Object root_1 = (Object)adaptor.nil();
 20934  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20935   
                         stream_DAY.nextNode()
 20936   
                         , root_1);
 20937   
 
 20938  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20939   
 
 20940  2 
                         adaptor.addChild(root_0, root_1);
 20941   
                         }
 20942   
 
 20943   
                     }
 20944   
 
 20945   
 
 20946  2 
                     retval.tree = root_0;
 20947   
 
 20948   
                     }
 20949  2 
                     break;
 20950   
                 case 30 :
 20951   
                     // com\\googlecode\\sparkleg\\Sparql.g:574:7: HOURS OPEN_BRACE expression CLOSE_BRACE
 20952   
                     {
 20953  2 
                     HOURS511=(Token)match(input,HOURS,FOLLOW_HOURS_in_builtInCall5706);
 20954  2 
                     stream_HOURS.add(HOURS511);
 20955   
 
 20956   
 
 20957  2 
                     OPEN_BRACE512=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5708);
 20958  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE512);
 20959   
 
 20960   
 
 20961  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5710);
 20962  2 
                     expression513=expression();
 20963   
 
 20964  2 
                     state._fsp--;
 20965   
 
 20966  2 
                     stream_expression.add(expression513.getTree());
 20967   
 
 20968  2 
                     CLOSE_BRACE514=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5712);
 20969  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE514);
 20970   
 
 20971   
 
 20972   
                     // AST REWRITE
 20973   
                     // elements: expression, HOURS
 20974   
                     // token labels:
 20975   
                     // rule labels: retval
 20976   
                     // token list labels:
 20977   
                     // rule list labels:
 20978   
                     // wildcard labels:
 20979  2 
                     retval.tree = root_0;
 20980  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 20981   
 
 20982  2 
                     root_0 = (Object)adaptor.nil();
 20983   
                     // 574:47: -> ^( HOURS expression )
 20984   
                     {
 20985   
                         // com\\googlecode\\sparkleg\\Sparql.g:574:50: ^( HOURS expression )
 20986   
                         {
 20987  2 
                         Object root_1 = (Object)adaptor.nil();
 20988  2 
                         root_1 = (Object)adaptor.becomeRoot(
 20989   
                         stream_HOURS.nextNode()
 20990   
                         , root_1);
 20991   
 
 20992  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 20993   
 
 20994  2 
                         adaptor.addChild(root_0, root_1);
 20995   
                         }
 20996   
 
 20997   
                     }
 20998   
 
 20999   
 
 21000  2 
                     retval.tree = root_0;
 21001   
 
 21002   
                     }
 21003  2 
                     break;
 21004   
                 case 31 :
 21005   
                     // com\\googlecode\\sparkleg\\Sparql.g:575:7: MINUTES OPEN_BRACE expression CLOSE_BRACE
 21006   
                     {
 21007  2 
                     MINUTES515=(Token)match(input,MINUTES,FOLLOW_MINUTES_in_builtInCall5728);
 21008  2 
                     stream_MINUTES.add(MINUTES515);
 21009   
 
 21010   
 
 21011  2 
                     OPEN_BRACE516=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5730);
 21012  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE516);
 21013   
 
 21014   
 
 21015  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5732);
 21016  2 
                     expression517=expression();
 21017   
 
 21018  2 
                     state._fsp--;
 21019   
 
 21020  2 
                     stream_expression.add(expression517.getTree());
 21021   
 
 21022  2 
                     CLOSE_BRACE518=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5734);
 21023  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE518);
 21024   
 
 21025   
 
 21026   
                     // AST REWRITE
 21027   
                     // elements: MINUTES, expression
 21028   
                     // token labels:
 21029   
                     // rule labels: retval
 21030   
                     // token list labels:
 21031   
                     // rule list labels:
 21032   
                     // wildcard labels:
 21033  2 
                     retval.tree = root_0;
 21034  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21035   
 
 21036  2 
                     root_0 = (Object)adaptor.nil();
 21037   
                     // 575:49: -> ^( MINUTES expression )
 21038   
                     {
 21039   
                         // com\\googlecode\\sparkleg\\Sparql.g:575:52: ^( MINUTES expression )
 21040   
                         {
 21041  2 
                         Object root_1 = (Object)adaptor.nil();
 21042  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21043   
                         stream_MINUTES.nextNode()
 21044   
                         , root_1);
 21045   
 
 21046  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21047   
 
 21048  2 
                         adaptor.addChild(root_0, root_1);
 21049   
                         }
 21050   
 
 21051   
                     }
 21052   
 
 21053   
 
 21054  2 
                     retval.tree = root_0;
 21055   
 
 21056   
                     }
 21057  2 
                     break;
 21058   
                 case 32 :
 21059   
                     // com\\googlecode\\sparkleg\\Sparql.g:576:7: SECONDS OPEN_BRACE expression CLOSE_BRACE
 21060   
                     {
 21061  2 
                     SECONDS519=(Token)match(input,SECONDS,FOLLOW_SECONDS_in_builtInCall5750);
 21062  2 
                     stream_SECONDS.add(SECONDS519);
 21063   
 
 21064   
 
 21065  2 
                     OPEN_BRACE520=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5752);
 21066  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE520);
 21067   
 
 21068   
 
 21069  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5754);
 21070  2 
                     expression521=expression();
 21071   
 
 21072  2 
                     state._fsp--;
 21073   
 
 21074  2 
                     stream_expression.add(expression521.getTree());
 21075   
 
 21076  2 
                     CLOSE_BRACE522=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5756);
 21077  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE522);
 21078   
 
 21079   
 
 21080   
                     // AST REWRITE
 21081   
                     // elements: expression, SECONDS
 21082   
                     // token labels:
 21083   
                     // rule labels: retval
 21084   
                     // token list labels:
 21085   
                     // rule list labels:
 21086   
                     // wildcard labels:
 21087  2 
                     retval.tree = root_0;
 21088  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21089   
 
 21090  2 
                     root_0 = (Object)adaptor.nil();
 21091   
                     // 576:49: -> ^( SECONDS expression )
 21092   
                     {
 21093   
                         // com\\googlecode\\sparkleg\\Sparql.g:576:52: ^( SECONDS expression )
 21094   
                         {
 21095  2 
                         Object root_1 = (Object)adaptor.nil();
 21096  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21097   
                         stream_SECONDS.nextNode()
 21098   
                         , root_1);
 21099   
 
 21100  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21101   
 
 21102  2 
                         adaptor.addChild(root_0, root_1);
 21103   
                         }
 21104   
 
 21105   
                     }
 21106   
 
 21107   
 
 21108  2 
                     retval.tree = root_0;
 21109   
 
 21110   
                     }
 21111  2 
                     break;
 21112   
                 case 33 :
 21113   
                     // com\\googlecode\\sparkleg\\Sparql.g:577:7: TIMEZONE OPEN_BRACE expression CLOSE_BRACE
 21114   
                     {
 21115  2 
                     TIMEZONE523=(Token)match(input,TIMEZONE,FOLLOW_TIMEZONE_in_builtInCall5772);
 21116  2 
                     stream_TIMEZONE.add(TIMEZONE523);
 21117   
 
 21118   
 
 21119  2 
                     OPEN_BRACE524=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5774);
 21120  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE524);
 21121   
 
 21122   
 
 21123  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5776);
 21124  2 
                     expression525=expression();
 21125   
 
 21126  2 
                     state._fsp--;
 21127   
 
 21128  2 
                     stream_expression.add(expression525.getTree());
 21129   
 
 21130  2 
                     CLOSE_BRACE526=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5778);
 21131  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE526);
 21132   
 
 21133   
 
 21134   
                     // AST REWRITE
 21135   
                     // elements: TIMEZONE, expression
 21136   
                     // token labels:
 21137   
                     // rule labels: retval
 21138   
                     // token list labels:
 21139   
                     // rule list labels:
 21140   
                     // wildcard labels:
 21141  2 
                     retval.tree = root_0;
 21142  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21143   
 
 21144  2 
                     root_0 = (Object)adaptor.nil();
 21145   
                     // 577:50: -> ^( TIMEZONE expression )
 21146   
                     {
 21147   
                         // com\\googlecode\\sparkleg\\Sparql.g:577:53: ^( TIMEZONE expression )
 21148   
                         {
 21149  2 
                         Object root_1 = (Object)adaptor.nil();
 21150  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21151   
                         stream_TIMEZONE.nextNode()
 21152   
                         , root_1);
 21153   
 
 21154  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21155   
 
 21156  2 
                         adaptor.addChild(root_0, root_1);
 21157   
                         }
 21158   
 
 21159   
                     }
 21160   
 
 21161   
 
 21162  2 
                     retval.tree = root_0;
 21163   
 
 21164   
                     }
 21165  2 
                     break;
 21166   
                 case 34 :
 21167   
                     // com\\googlecode\\sparkleg\\Sparql.g:578:7: TZ OPEN_BRACE expression CLOSE_BRACE
 21168   
                     {
 21169  2 
                     TZ527=(Token)match(input,TZ,FOLLOW_TZ_in_builtInCall5794);
 21170  2 
                     stream_TZ.add(TZ527);
 21171   
 
 21172   
 
 21173  2 
                     OPEN_BRACE528=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5796);
 21174  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE528);
 21175   
 
 21176   
 
 21177  2 
                     pushFollow(FOLLOW_expression_in_builtInCall5798);
 21178  2 
                     expression529=expression();
 21179   
 
 21180  2 
                     state._fsp--;
 21181   
 
 21182  2 
                     stream_expression.add(expression529.getTree());
 21183   
 
 21184  2 
                     CLOSE_BRACE530=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5800);
 21185  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE530);
 21186   
 
 21187   
 
 21188   
                     // AST REWRITE
 21189   
                     // elements: expression, TZ
 21190   
                     // token labels:
 21191   
                     // rule labels: retval
 21192   
                     // token list labels:
 21193   
                     // rule list labels:
 21194   
                     // wildcard labels:
 21195  2 
                     retval.tree = root_0;
 21196  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21197   
 
 21198  2 
                     root_0 = (Object)adaptor.nil();
 21199   
                     // 578:44: -> ^( TZ expression )
 21200   
                     {
 21201   
                         // com\\googlecode\\sparkleg\\Sparql.g:578:47: ^( TZ expression )
 21202   
                         {
 21203  2 
                         Object root_1 = (Object)adaptor.nil();
 21204  2 
                         root_1 = (Object)adaptor.becomeRoot(
 21205   
                         stream_TZ.nextNode()
 21206   
                         , root_1);
 21207   
 
 21208  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21209   
 
 21210  2 
                         adaptor.addChild(root_0, root_1);
 21211   
                         }
 21212   
 
 21213   
                     }
 21214   
 
 21215   
 
 21216  2 
                     retval.tree = root_0;
 21217   
 
 21218   
                     }
 21219  2 
                     break;
 21220   
                 case 35 :
 21221   
                     // com\\googlecode\\sparkleg\\Sparql.g:579:7: NOW nil
 21222   
                     {
 21223  2 
                     NOW531=(Token)match(input,NOW,FOLLOW_NOW_in_builtInCall5816);
 21224  2 
                     stream_NOW.add(NOW531);
 21225   
 
 21226   
 
 21227  2 
                     pushFollow(FOLLOW_nil_in_builtInCall5818);
 21228  2 
                     nil532=nil();
 21229   
 
 21230  2 
                     state._fsp--;
 21231   
 
 21232  2 
                     stream_nil.add(nil532.getTree());
 21233   
 
 21234   
                     // AST REWRITE
 21235   
                     // elements: NOW
 21236   
                     // token labels:
 21237   
                     // rule labels: retval
 21238   
                     // token list labels:
 21239   
                     // rule list labels:
 21240   
                     // wildcard labels:
 21241  2 
                     retval.tree = root_0;
 21242  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21243   
 
 21244  2 
                     root_0 = (Object)adaptor.nil();
 21245   
                     // 579:15: -> NOW
 21246   
                     {
 21247  2 
                         adaptor.addChild(root_0,
 21248   
                         stream_NOW.nextNode()
 21249   
                         );
 21250   
 
 21251   
                     }
 21252   
 
 21253   
 
 21254  2 
                     retval.tree = root_0;
 21255   
 
 21256   
                     }
 21257  2 
                     break;
 21258   
                 case 36 :
 21259   
                     // com\\googlecode\\sparkleg\\Sparql.g:580:7: MD5 OPEN_BRACE expression CLOSE_BRACE
 21260   
                     {
 21261  4 
                     MD5533=(Token)match(input,MD5,FOLLOW_MD5_in_builtInCall5830);
 21262  4 
                     stream_MD5.add(MD5533);
 21263   
 
 21264   
 
 21265  4 
                     OPEN_BRACE534=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5832);
 21266  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE534);
 21267   
 
 21268   
 
 21269  4 
                     pushFollow(FOLLOW_expression_in_builtInCall5834);
 21270  4 
                     expression535=expression();
 21271   
 
 21272  4 
                     state._fsp--;
 21273   
 
 21274  4 
                     stream_expression.add(expression535.getTree());
 21275   
 
 21276  4 
                     CLOSE_BRACE536=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5836);
 21277  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE536);
 21278   
 
 21279   
 
 21280   
                     // AST REWRITE
 21281   
                     // elements: MD5, expression
 21282   
                     // token labels:
 21283   
                     // rule labels: retval
 21284   
                     // token list labels:
 21285   
                     // rule list labels:
 21286   
                     // wildcard labels:
 21287  4 
                     retval.tree = root_0;
 21288  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21289   
 
 21290  4 
                     root_0 = (Object)adaptor.nil();
 21291   
                     // 580:45: -> ^( MD5 expression )
 21292   
                     {
 21293   
                         // com\\googlecode\\sparkleg\\Sparql.g:580:48: ^( MD5 expression )
 21294   
                         {
 21295  4 
                         Object root_1 = (Object)adaptor.nil();
 21296  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21297   
                         stream_MD5.nextNode()
 21298   
                         , root_1);
 21299   
 
 21300  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21301   
 
 21302  4 
                         adaptor.addChild(root_0, root_1);
 21303   
                         }
 21304   
 
 21305   
                     }
 21306   
 
 21307   
 
 21308  4 
                     retval.tree = root_0;
 21309   
 
 21310   
                     }
 21311  4 
                     break;
 21312   
                 case 37 :
 21313   
                     // com\\googlecode\\sparkleg\\Sparql.g:581:7: SHA1 OPEN_BRACE expression CLOSE_BRACE
 21314   
                     {
 21315  4 
                     SHA1537=(Token)match(input,SHA1,FOLLOW_SHA1_in_builtInCall5852);
 21316  4 
                     stream_SHA1.add(SHA1537);
 21317   
 
 21318   
 
 21319  4 
                     OPEN_BRACE538=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5854);
 21320  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE538);
 21321   
 
 21322   
 
 21323  4 
                     pushFollow(FOLLOW_expression_in_builtInCall5856);
 21324  4 
                     expression539=expression();
 21325   
 
 21326  4 
                     state._fsp--;
 21327   
 
 21328  4 
                     stream_expression.add(expression539.getTree());
 21329   
 
 21330  4 
                     CLOSE_BRACE540=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5858);
 21331  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE540);
 21332   
 
 21333   
 
 21334   
                     // AST REWRITE
 21335   
                     // elements: expression, SHA1
 21336   
                     // token labels:
 21337   
                     // rule labels: retval
 21338   
                     // token list labels:
 21339   
                     // rule list labels:
 21340   
                     // wildcard labels:
 21341  4 
                     retval.tree = root_0;
 21342  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21343   
 
 21344  4 
                     root_0 = (Object)adaptor.nil();
 21345   
                     // 581:46: -> ^( SHA1 expression )
 21346   
                     {
 21347   
                         // com\\googlecode\\sparkleg\\Sparql.g:581:49: ^( SHA1 expression )
 21348   
                         {
 21349  4 
                         Object root_1 = (Object)adaptor.nil();
 21350  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21351   
                         stream_SHA1.nextNode()
 21352   
                         , root_1);
 21353   
 
 21354  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21355   
 
 21356  4 
                         adaptor.addChild(root_0, root_1);
 21357   
                         }
 21358   
 
 21359   
                     }
 21360   
 
 21361   
 
 21362  4 
                     retval.tree = root_0;
 21363   
 
 21364   
                     }
 21365  4 
                     break;
 21366   
                 case 38 :
 21367   
                     // com\\googlecode\\sparkleg\\Sparql.g:582:7: SHA224 OPEN_BRACE expression CLOSE_BRACE
 21368   
                     {
 21369  0 
                     SHA224541=(Token)match(input,SHA224,FOLLOW_SHA224_in_builtInCall5874);
 21370  0 
                     stream_SHA224.add(SHA224541);
 21371   
 
 21372   
 
 21373  0 
                     OPEN_BRACE542=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5876);
 21374  0 
                     stream_OPEN_BRACE.add(OPEN_BRACE542);
 21375   
 
 21376   
 
 21377  0 
                     pushFollow(FOLLOW_expression_in_builtInCall5878);
 21378  0 
                     expression543=expression();
 21379   
 
 21380  0 
                     state._fsp--;
 21381   
 
 21382  0 
                     stream_expression.add(expression543.getTree());
 21383   
 
 21384  0 
                     CLOSE_BRACE544=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5880);
 21385  0 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE544);
 21386   
 
 21387   
 
 21388   
                     // AST REWRITE
 21389   
                     // elements: expression, SHA224
 21390   
                     // token labels:
 21391   
                     // rule labels: retval
 21392   
                     // token list labels:
 21393   
                     // rule list labels:
 21394   
                     // wildcard labels:
 21395  0 
                     retval.tree = root_0;
 21396  0 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21397   
 
 21398  0 
                     root_0 = (Object)adaptor.nil();
 21399   
                     // 582:48: -> ^( SHA224 expression )
 21400   
                     {
 21401   
                         // com\\googlecode\\sparkleg\\Sparql.g:582:51: ^( SHA224 expression )
 21402   
                         {
 21403  0 
                         Object root_1 = (Object)adaptor.nil();
 21404  0 
                         root_1 = (Object)adaptor.becomeRoot(
 21405   
                         stream_SHA224.nextNode()
 21406   
                         , root_1);
 21407   
 
 21408  0 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21409   
 
 21410  0 
                         adaptor.addChild(root_0, root_1);
 21411   
                         }
 21412   
 
 21413   
                     }
 21414   
 
 21415   
 
 21416  0 
                     retval.tree = root_0;
 21417   
 
 21418   
                     }
 21419  0 
                     break;
 21420   
                 case 39 :
 21421   
                     // com\\googlecode\\sparkleg\\Sparql.g:583:7: SHA256 OPEN_BRACE expression CLOSE_BRACE
 21422   
                     {
 21423  4 
                     SHA256545=(Token)match(input,SHA256,FOLLOW_SHA256_in_builtInCall5896);
 21424  4 
                     stream_SHA256.add(SHA256545);
 21425   
 
 21426   
 
 21427  4 
                     OPEN_BRACE546=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5898);
 21428  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE546);
 21429   
 
 21430   
 
 21431  4 
                     pushFollow(FOLLOW_expression_in_builtInCall5900);
 21432  4 
                     expression547=expression();
 21433   
 
 21434  4 
                     state._fsp--;
 21435   
 
 21436  4 
                     stream_expression.add(expression547.getTree());
 21437   
 
 21438  4 
                     CLOSE_BRACE548=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5902);
 21439  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE548);
 21440   
 
 21441   
 
 21442   
                     // AST REWRITE
 21443   
                     // elements: SHA256, expression
 21444   
                     // token labels:
 21445   
                     // rule labels: retval
 21446   
                     // token list labels:
 21447   
                     // rule list labels:
 21448   
                     // wildcard labels:
 21449  4 
                     retval.tree = root_0;
 21450  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21451   
 
 21452  4 
                     root_0 = (Object)adaptor.nil();
 21453   
                     // 583:48: -> ^( SHA256 expression )
 21454   
                     {
 21455   
                         // com\\googlecode\\sparkleg\\Sparql.g:583:51: ^( SHA256 expression )
 21456   
                         {
 21457  4 
                         Object root_1 = (Object)adaptor.nil();
 21458  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21459   
                         stream_SHA256.nextNode()
 21460   
                         , root_1);
 21461   
 
 21462  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21463   
 
 21464  4 
                         adaptor.addChild(root_0, root_1);
 21465   
                         }
 21466   
 
 21467   
                     }
 21468   
 
 21469   
 
 21470  4 
                     retval.tree = root_0;
 21471   
 
 21472   
                     }
 21473  4 
                     break;
 21474   
                 case 40 :
 21475   
                     // com\\googlecode\\sparkleg\\Sparql.g:584:7: SHA384 OPEN_BRACE expression CLOSE_BRACE
 21476   
                     {
 21477  4 
                     SHA384549=(Token)match(input,SHA384,FOLLOW_SHA384_in_builtInCall5918);
 21478  4 
                     stream_SHA384.add(SHA384549);
 21479   
 
 21480   
 
 21481  4 
                     OPEN_BRACE550=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5920);
 21482  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE550);
 21483   
 
 21484   
 
 21485  4 
                     pushFollow(FOLLOW_expression_in_builtInCall5922);
 21486  4 
                     expression551=expression();
 21487   
 
 21488  4 
                     state._fsp--;
 21489   
 
 21490  4 
                     stream_expression.add(expression551.getTree());
 21491   
 
 21492  4 
                     CLOSE_BRACE552=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5924);
 21493  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE552);
 21494   
 
 21495   
 
 21496   
                     // AST REWRITE
 21497   
                     // elements: SHA384, expression
 21498   
                     // token labels:
 21499   
                     // rule labels: retval
 21500   
                     // token list labels:
 21501   
                     // rule list labels:
 21502   
                     // wildcard labels:
 21503  4 
                     retval.tree = root_0;
 21504  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21505   
 
 21506  4 
                     root_0 = (Object)adaptor.nil();
 21507   
                     // 584:48: -> ^( SHA384 expression )
 21508   
                     {
 21509   
                         // com\\googlecode\\sparkleg\\Sparql.g:584:51: ^( SHA384 expression )
 21510   
                         {
 21511  4 
                         Object root_1 = (Object)adaptor.nil();
 21512  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21513   
                         stream_SHA384.nextNode()
 21514   
                         , root_1);
 21515   
 
 21516  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21517   
 
 21518  4 
                         adaptor.addChild(root_0, root_1);
 21519   
                         }
 21520   
 
 21521   
                     }
 21522   
 
 21523   
 
 21524  4 
                     retval.tree = root_0;
 21525   
 
 21526   
                     }
 21527  4 
                     break;
 21528   
                 case 41 :
 21529   
                     // com\\googlecode\\sparkleg\\Sparql.g:585:7: SHA512 OPEN_BRACE expression CLOSE_BRACE
 21530   
                     {
 21531  4 
                     SHA512553=(Token)match(input,SHA512,FOLLOW_SHA512_in_builtInCall5940);
 21532  4 
                     stream_SHA512.add(SHA512553);
 21533   
 
 21534   
 
 21535  4 
                     OPEN_BRACE554=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5942);
 21536  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE554);
 21537   
 
 21538   
 
 21539  4 
                     pushFollow(FOLLOW_expression_in_builtInCall5944);
 21540  4 
                     expression555=expression();
 21541   
 
 21542  4 
                     state._fsp--;
 21543   
 
 21544  4 
                     stream_expression.add(expression555.getTree());
 21545   
 
 21546  4 
                     CLOSE_BRACE556=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall5946);
 21547  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE556);
 21548   
 
 21549   
 
 21550   
                     // AST REWRITE
 21551   
                     // elements: expression, SHA512
 21552   
                     // token labels:
 21553   
                     // rule labels: retval
 21554   
                     // token list labels:
 21555   
                     // rule list labels:
 21556   
                     // wildcard labels:
 21557  4 
                     retval.tree = root_0;
 21558  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21559   
 
 21560  4 
                     root_0 = (Object)adaptor.nil();
 21561   
                     // 585:48: -> ^( SHA512 expression )
 21562   
                     {
 21563   
                         // com\\googlecode\\sparkleg\\Sparql.g:585:51: ^( SHA512 expression )
 21564   
                         {
 21565  4 
                         Object root_1 = (Object)adaptor.nil();
 21566  4 
                         root_1 = (Object)adaptor.becomeRoot(
 21567   
                         stream_SHA512.nextNode()
 21568   
                         , root_1);
 21569   
 
 21570  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21571   
 
 21572  4 
                         adaptor.addChild(root_0, root_1);
 21573   
                         }
 21574   
 
 21575   
                     }
 21576   
 
 21577   
 
 21578  4 
                     retval.tree = root_0;
 21579   
 
 21580   
                     }
 21581  4 
                     break;
 21582   
                 case 42 :
 21583   
                     // com\\googlecode\\sparkleg\\Sparql.g:586:7: COALESCE expressionList
 21584   
                     {
 21585  12 
                     COALESCE557=(Token)match(input,COALESCE,FOLLOW_COALESCE_in_builtInCall5962);
 21586  12 
                     stream_COALESCE.add(COALESCE557);
 21587   
 
 21588   
 
 21589  12 
                     pushFollow(FOLLOW_expressionList_in_builtInCall5964);
 21590  12 
                     expressionList558=expressionList();
 21591   
 
 21592  12 
                     state._fsp--;
 21593   
 
 21594  12 
                     stream_expressionList.add(expressionList558.getTree());
 21595   
 
 21596   
                     // AST REWRITE
 21597   
                     // elements: expressionList, COALESCE
 21598   
                     // token labels:
 21599   
                     // rule labels: retval
 21600   
                     // token list labels:
 21601   
                     // rule list labels:
 21602   
                     // wildcard labels:
 21603  12 
                     retval.tree = root_0;
 21604  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21605   
 
 21606  12 
                     root_0 = (Object)adaptor.nil();
 21607   
                     // 586:31: -> ^( COALESCE expressionList )
 21608   
                     {
 21609   
                         // com\\googlecode\\sparkleg\\Sparql.g:586:34: ^( COALESCE expressionList )
 21610   
                         {
 21611  12 
                         Object root_1 = (Object)adaptor.nil();
 21612  12 
                         root_1 = (Object)adaptor.becomeRoot(
 21613   
                         stream_COALESCE.nextNode()
 21614   
                         , root_1);
 21615   
 
 21616  12 
                         adaptor.addChild(root_1, stream_expressionList.nextTree());
 21617   
 
 21618  12 
                         adaptor.addChild(root_0, root_1);
 21619   
                         }
 21620   
 
 21621   
                     }
 21622   
 
 21623   
 
 21624  12 
                     retval.tree = root_0;
 21625   
 
 21626   
                     }
 21627  12 
                     break;
 21628   
                 case 43 :
 21629   
                     // com\\googlecode\\sparkleg\\Sparql.g:587:7: IF OPEN_BRACE e1= expression COMMA e2= expression COMMA e3= expression CLOSE_BRACE
 21630   
                     {
 21631  6 
                     IF559=(Token)match(input,IF,FOLLOW_IF_in_builtInCall5980);
 21632  6 
                     stream_IF.add(IF559);
 21633   
 
 21634   
 
 21635  6 
                     OPEN_BRACE560=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall5982);
 21636  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE560);
 21637   
 
 21638   
 
 21639  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5986);
 21640  6 
                     e1=expression();
 21641   
 
 21642  6 
                     state._fsp--;
 21643   
 
 21644  6 
                     stream_expression.add(e1.getTree());
 21645   
 
 21646  6 
                     COMMA561=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5988);
 21647  6 
                     stream_COMMA.add(COMMA561);
 21648   
 
 21649   
 
 21650  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5992);
 21651  6 
                     e2=expression();
 21652   
 
 21653  6 
                     state._fsp--;
 21654   
 
 21655  6 
                     stream_expression.add(e2.getTree());
 21656   
 
 21657  6 
                     COMMA562=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall5994);
 21658  6 
                     stream_COMMA.add(COMMA562);
 21659   
 
 21660   
 
 21661  6 
                     pushFollow(FOLLOW_expression_in_builtInCall5998);
 21662  6 
                     e3=expression();
 21663   
 
 21664  6 
                     state._fsp--;
 21665   
 
 21666  6 
                     stream_expression.add(e3.getTree());
 21667   
 
 21668  6 
                     CLOSE_BRACE563=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6000);
 21669  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE563);
 21670   
 
 21671   
 
 21672   
                     // AST REWRITE
 21673   
                     // elements: e2, e1, e3, IF
 21674   
                     // token labels:
 21675   
                     // rule labels: e3, retval, e1, e2
 21676   
                     // token list labels:
 21677   
                     // rule list labels:
 21678   
                     // wildcard labels:
 21679  6 
                     retval.tree = root_0;
 21680  6 
                     RewriteRuleSubtreeStream stream_e3=new RewriteRuleSubtreeStream(adaptor,"rule e3",e3!=null?e3.tree:null);
 21681  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21682  6 
                     RewriteRuleSubtreeStream stream_e1=new RewriteRuleSubtreeStream(adaptor,"rule e1",e1!=null?e1.tree:null);
 21683  6 
                     RewriteRuleSubtreeStream stream_e2=new RewriteRuleSubtreeStream(adaptor,"rule e2",e2!=null?e2.tree:null);
 21684   
 
 21685  6 
                     root_0 = (Object)adaptor.nil();
 21686   
                     // 587:87: -> ^( IF $e1 $e2 $e3)
 21687   
                     {
 21688   
                         // com\\googlecode\\sparkleg\\Sparql.g:587:90: ^( IF $e1 $e2 $e3)
 21689   
                         {
 21690  6 
                         Object root_1 = (Object)adaptor.nil();
 21691  6 
                         root_1 = (Object)adaptor.becomeRoot(
 21692   
                         stream_IF.nextNode()
 21693   
                         , root_1);
 21694   
 
 21695  6 
                         adaptor.addChild(root_1, stream_e1.nextTree());
 21696   
 
 21697  6 
                         adaptor.addChild(root_1, stream_e2.nextTree());
 21698   
 
 21699  6 
                         adaptor.addChild(root_1, stream_e3.nextTree());
 21700   
 
 21701  6 
                         adaptor.addChild(root_0, root_1);
 21702   
                         }
 21703   
 
 21704   
                     }
 21705   
 
 21706   
 
 21707  6 
                     retval.tree = root_0;
 21708   
 
 21709   
                     }
 21710  6 
                     break;
 21711   
                 case 44 :
 21712   
                     // com\\googlecode\\sparkleg\\Sparql.g:588:7: STRLANG OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21713   
                     {
 21714  6 
                     STRLANG564=(Token)match(input,STRLANG,FOLLOW_STRLANG_in_builtInCall6023);
 21715  6 
                     stream_STRLANG.add(STRLANG564);
 21716   
 
 21717   
 
 21718  6 
                     OPEN_BRACE565=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6025);
 21719  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE565);
 21720   
 
 21721   
 
 21722  6 
                     pushFollow(FOLLOW_expression_in_builtInCall6027);
 21723  6 
                     expression566=expression();
 21724   
 
 21725  6 
                     state._fsp--;
 21726   
 
 21727  6 
                     stream_expression.add(expression566.getTree());
 21728   
 
 21729  6 
                     COMMA567=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6029);
 21730  6 
                     stream_COMMA.add(COMMA567);
 21731   
 
 21732   
 
 21733  6 
                     pushFollow(FOLLOW_expression_in_builtInCall6031);
 21734  6 
                     expression568=expression();
 21735   
 
 21736  6 
                     state._fsp--;
 21737   
 
 21738  6 
                     stream_expression.add(expression568.getTree());
 21739   
 
 21740  6 
                     CLOSE_BRACE569=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6033);
 21741  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE569);
 21742   
 
 21743   
 
 21744   
                     // AST REWRITE
 21745   
                     // elements: STRLANG, expression, expression
 21746   
                     // token labels:
 21747   
                     // rule labels: retval
 21748   
                     // token list labels:
 21749   
                     // rule list labels:
 21750   
                     // wildcard labels:
 21751  6 
                     retval.tree = root_0;
 21752  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21753   
 
 21754  6 
                     root_0 = (Object)adaptor.nil();
 21755   
                     // 588:66: -> ^( STRLANG expression expression )
 21756   
                     {
 21757   
                         // com\\googlecode\\sparkleg\\Sparql.g:588:69: ^( STRLANG expression expression )
 21758   
                         {
 21759  6 
                         Object root_1 = (Object)adaptor.nil();
 21760  6 
                         root_1 = (Object)adaptor.becomeRoot(
 21761   
                         stream_STRLANG.nextNode()
 21762   
                         , root_1);
 21763   
 
 21764  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21765   
 
 21766  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21767   
 
 21768  6 
                         adaptor.addChild(root_0, root_1);
 21769   
                         }
 21770   
 
 21771   
                     }
 21772   
 
 21773   
 
 21774  6 
                     retval.tree = root_0;
 21775   
 
 21776   
                     }
 21777  6 
                     break;
 21778   
                 case 45 :
 21779   
                     // com\\googlecode\\sparkleg\\Sparql.g:589:7: STRDT OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21780   
                     {
 21781  6 
                     STRDT570=(Token)match(input,STRDT,FOLLOW_STRDT_in_builtInCall6051);
 21782  6 
                     stream_STRDT.add(STRDT570);
 21783   
 
 21784   
 
 21785  6 
                     OPEN_BRACE571=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6053);
 21786  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE571);
 21787   
 
 21788   
 
 21789  6 
                     pushFollow(FOLLOW_expression_in_builtInCall6055);
 21790  6 
                     expression572=expression();
 21791   
 
 21792  6 
                     state._fsp--;
 21793   
 
 21794  6 
                     stream_expression.add(expression572.getTree());
 21795   
 
 21796  6 
                     COMMA573=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6057);
 21797  6 
                     stream_COMMA.add(COMMA573);
 21798   
 
 21799   
 
 21800  6 
                     pushFollow(FOLLOW_expression_in_builtInCall6059);
 21801  6 
                     expression574=expression();
 21802   
 
 21803  6 
                     state._fsp--;
 21804   
 
 21805  6 
                     stream_expression.add(expression574.getTree());
 21806   
 
 21807  6 
                     CLOSE_BRACE575=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6061);
 21808  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE575);
 21809   
 
 21810   
 
 21811   
                     // AST REWRITE
 21812   
                     // elements: expression, STRDT, expression
 21813   
                     // token labels:
 21814   
                     // rule labels: retval
 21815   
                     // token list labels:
 21816   
                     // rule list labels:
 21817   
                     // wildcard labels:
 21818  6 
                     retval.tree = root_0;
 21819  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21820   
 
 21821  6 
                     root_0 = (Object)adaptor.nil();
 21822   
                     // 589:64: -> ^( STRDT expression expression )
 21823   
                     {
 21824   
                         // com\\googlecode\\sparkleg\\Sparql.g:589:67: ^( STRDT expression expression )
 21825   
                         {
 21826  6 
                         Object root_1 = (Object)adaptor.nil();
 21827  6 
                         root_1 = (Object)adaptor.becomeRoot(
 21828   
                         stream_STRDT.nextNode()
 21829   
                         , root_1);
 21830   
 
 21831  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21832   
 
 21833  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21834   
 
 21835  6 
                         adaptor.addChild(root_0, root_1);
 21836   
                         }
 21837   
 
 21838   
                     }
 21839   
 
 21840   
 
 21841  6 
                     retval.tree = root_0;
 21842   
 
 21843   
                     }
 21844  6 
                     break;
 21845   
                 case 46 :
 21846   
                     // com\\googlecode\\sparkleg\\Sparql.g:590:7: SAMETERM OPEN_BRACE expression COMMA expression CLOSE_BRACE
 21847   
                     {
 21848  30 
                     SAMETERM576=(Token)match(input,SAMETERM,FOLLOW_SAMETERM_in_builtInCall6079);
 21849  30 
                     stream_SAMETERM.add(SAMETERM576);
 21850   
 
 21851   
 
 21852  30 
                     OPEN_BRACE577=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6081);
 21853  30 
                     stream_OPEN_BRACE.add(OPEN_BRACE577);
 21854   
 
 21855   
 
 21856  30 
                     pushFollow(FOLLOW_expression_in_builtInCall6083);
 21857  30 
                     expression578=expression();
 21858   
 
 21859  30 
                     state._fsp--;
 21860   
 
 21861  30 
                     stream_expression.add(expression578.getTree());
 21862   
 
 21863  30 
                     COMMA579=(Token)match(input,COMMA,FOLLOW_COMMA_in_builtInCall6085);
 21864  30 
                     stream_COMMA.add(COMMA579);
 21865   
 
 21866   
 
 21867  30 
                     pushFollow(FOLLOW_expression_in_builtInCall6087);
 21868  30 
                     expression580=expression();
 21869   
 
 21870  30 
                     state._fsp--;
 21871   
 
 21872  30 
                     stream_expression.add(expression580.getTree());
 21873   
 
 21874  30 
                     CLOSE_BRACE581=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6089);
 21875  30 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE581);
 21876   
 
 21877   
 
 21878   
                     // AST REWRITE
 21879   
                     // elements: expression, expression, SAMETERM
 21880   
                     // token labels:
 21881   
                     // rule labels: retval
 21882   
                     // token list labels:
 21883   
                     // rule list labels:
 21884   
                     // wildcard labels:
 21885  30 
                     retval.tree = root_0;
 21886  30 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21887   
 
 21888  30 
                     root_0 = (Object)adaptor.nil();
 21889   
                     // 590:67: -> ^( SAMETERM expression expression )
 21890   
                     {
 21891   
                         // com\\googlecode\\sparkleg\\Sparql.g:590:70: ^( SAMETERM expression expression )
 21892   
                         {
 21893  30 
                         Object root_1 = (Object)adaptor.nil();
 21894  30 
                         root_1 = (Object)adaptor.becomeRoot(
 21895   
                         stream_SAMETERM.nextNode()
 21896   
                         , root_1);
 21897   
 
 21898  30 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21899   
 
 21900  30 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21901   
 
 21902  30 
                         adaptor.addChild(root_0, root_1);
 21903   
                         }
 21904   
 
 21905   
                     }
 21906   
 
 21907   
 
 21908  30 
                     retval.tree = root_0;
 21909   
 
 21910   
                     }
 21911  30 
                     break;
 21912   
                 case 47 :
 21913   
                     // com\\googlecode\\sparkleg\\Sparql.g:591:7: ISIRI OPEN_BRACE expression CLOSE_BRACE
 21914   
                     {
 21915  8 
                     ISIRI582=(Token)match(input,ISIRI,FOLLOW_ISIRI_in_builtInCall6107);
 21916  8 
                     stream_ISIRI.add(ISIRI582);
 21917   
 
 21918   
 
 21919  8 
                     OPEN_BRACE583=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6109);
 21920  8 
                     stream_OPEN_BRACE.add(OPEN_BRACE583);
 21921   
 
 21922   
 
 21923  8 
                     pushFollow(FOLLOW_expression_in_builtInCall6111);
 21924  8 
                     expression584=expression();
 21925   
 
 21926  8 
                     state._fsp--;
 21927   
 
 21928  8 
                     stream_expression.add(expression584.getTree());
 21929   
 
 21930  8 
                     CLOSE_BRACE585=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6113);
 21931  8 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE585);
 21932   
 
 21933   
 
 21934   
                     // AST REWRITE
 21935   
                     // elements: expression, ISIRI
 21936   
                     // token labels:
 21937   
                     // rule labels: retval
 21938   
                     // token list labels:
 21939   
                     // rule list labels:
 21940   
                     // wildcard labels:
 21941  8 
                     retval.tree = root_0;
 21942  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21943   
 
 21944  8 
                     root_0 = (Object)adaptor.nil();
 21945   
                     // 591:47: -> ^( ISIRI expression )
 21946   
                     {
 21947   
                         // com\\googlecode\\sparkleg\\Sparql.g:591:50: ^( ISIRI expression )
 21948   
                         {
 21949  8 
                         Object root_1 = (Object)adaptor.nil();
 21950  8 
                         root_1 = (Object)adaptor.becomeRoot(
 21951   
                         stream_ISIRI.nextNode()
 21952   
                         , root_1);
 21953   
 
 21954  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 21955   
 
 21956  8 
                         adaptor.addChild(root_0, root_1);
 21957   
                         }
 21958   
 
 21959   
                     }
 21960   
 
 21961   
 
 21962  8 
                     retval.tree = root_0;
 21963   
 
 21964   
                     }
 21965  8 
                     break;
 21966   
                 case 48 :
 21967   
                     // com\\googlecode\\sparkleg\\Sparql.g:592:7: ISURI OPEN_BRACE expression CLOSE_BRACE
 21968   
                     {
 21969  2 
                     ISURI586=(Token)match(input,ISURI,FOLLOW_ISURI_in_builtInCall6129);
 21970  2 
                     stream_ISURI.add(ISURI586);
 21971   
 
 21972   
 
 21973  2 
                     OPEN_BRACE587=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6131);
 21974  2 
                     stream_OPEN_BRACE.add(OPEN_BRACE587);
 21975   
 
 21976   
 
 21977  2 
                     pushFollow(FOLLOW_expression_in_builtInCall6133);
 21978  2 
                     expression588=expression();
 21979   
 
 21980  2 
                     state._fsp--;
 21981   
 
 21982  2 
                     stream_expression.add(expression588.getTree());
 21983   
 
 21984  2 
                     CLOSE_BRACE589=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6135);
 21985  2 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE589);
 21986   
 
 21987   
 
 21988   
                     // AST REWRITE
 21989   
                     // elements: expression, ISURI
 21990   
                     // token labels:
 21991   
                     // rule labels: retval
 21992   
                     // token list labels:
 21993   
                     // rule list labels:
 21994   
                     // wildcard labels:
 21995  2 
                     retval.tree = root_0;
 21996  2 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 21997   
 
 21998  2 
                     root_0 = (Object)adaptor.nil();
 21999   
                     // 592:47: -> ^( ISURI expression )
 22000   
                     {
 22001   
                         // com\\googlecode\\sparkleg\\Sparql.g:592:50: ^( ISURI expression )
 22002   
                         {
 22003  2 
                         Object root_1 = (Object)adaptor.nil();
 22004  2 
                         root_1 = (Object)adaptor.becomeRoot(
 22005   
                         stream_ISURI.nextNode()
 22006   
                         , root_1);
 22007   
 
 22008  2 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22009   
 
 22010  2 
                         adaptor.addChild(root_0, root_1);
 22011   
                         }
 22012   
 
 22013   
                     }
 22014   
 
 22015   
 
 22016  2 
                     retval.tree = root_0;
 22017   
 
 22018   
                     }
 22019  2 
                     break;
 22020   
                 case 49 :
 22021   
                     // com\\googlecode\\sparkleg\\Sparql.g:593:7: ISBLANK OPEN_BRACE expression CLOSE_BRACE
 22022   
                     {
 22023  8 
                     ISBLANK590=(Token)match(input,ISBLANK,FOLLOW_ISBLANK_in_builtInCall6151);
 22024  8 
                     stream_ISBLANK.add(ISBLANK590);
 22025   
 
 22026   
 
 22027  8 
                     OPEN_BRACE591=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6153);
 22028  8 
                     stream_OPEN_BRACE.add(OPEN_BRACE591);
 22029   
 
 22030   
 
 22031  8 
                     pushFollow(FOLLOW_expression_in_builtInCall6155);
 22032  8 
                     expression592=expression();
 22033   
 
 22034  8 
                     state._fsp--;
 22035   
 
 22036  8 
                     stream_expression.add(expression592.getTree());
 22037   
 
 22038  8 
                     CLOSE_BRACE593=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6157);
 22039  8 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE593);
 22040   
 
 22041   
 
 22042   
                     // AST REWRITE
 22043   
                     // elements: ISBLANK, expression
 22044   
                     // token labels:
 22045   
                     // rule labels: retval
 22046   
                     // token list labels:
 22047   
                     // rule list labels:
 22048   
                     // wildcard labels:
 22049  8 
                     retval.tree = root_0;
 22050  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22051   
 
 22052  8 
                     root_0 = (Object)adaptor.nil();
 22053   
                     // 593:49: -> ^( ISBLANK expression )
 22054   
                     {
 22055   
                         // com\\googlecode\\sparkleg\\Sparql.g:593:52: ^( ISBLANK expression )
 22056   
                         {
 22057  8 
                         Object root_1 = (Object)adaptor.nil();
 22058  8 
                         root_1 = (Object)adaptor.becomeRoot(
 22059   
                         stream_ISBLANK.nextNode()
 22060   
                         , root_1);
 22061   
 
 22062  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22063   
 
 22064  8 
                         adaptor.addChild(root_0, root_1);
 22065   
                         }
 22066   
 
 22067   
                     }
 22068   
 
 22069   
 
 22070  8 
                     retval.tree = root_0;
 22071   
 
 22072   
                     }
 22073  8 
                     break;
 22074   
                 case 50 :
 22075   
                     // com\\googlecode\\sparkleg\\Sparql.g:594:7: ISLITERAL OPEN_BRACE expression CLOSE_BRACE
 22076   
                     {
 22077  8 
                     ISLITERAL594=(Token)match(input,ISLITERAL,FOLLOW_ISLITERAL_in_builtInCall6174);
 22078  8 
                     stream_ISLITERAL.add(ISLITERAL594);
 22079   
 
 22080   
 
 22081  8 
                     OPEN_BRACE595=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6176);
 22082  8 
                     stream_OPEN_BRACE.add(OPEN_BRACE595);
 22083   
 
 22084   
 
 22085  8 
                     pushFollow(FOLLOW_expression_in_builtInCall6178);
 22086  8 
                     expression596=expression();
 22087   
 
 22088  8 
                     state._fsp--;
 22089   
 
 22090  8 
                     stream_expression.add(expression596.getTree());
 22091   
 
 22092  8 
                     CLOSE_BRACE597=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6180);
 22093  8 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE597);
 22094   
 
 22095   
 
 22096   
                     // AST REWRITE
 22097   
                     // elements: expression, ISLITERAL
 22098   
                     // token labels:
 22099   
                     // rule labels: retval
 22100   
                     // token list labels:
 22101   
                     // rule list labels:
 22102   
                     // wildcard labels:
 22103  8 
                     retval.tree = root_0;
 22104  8 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22105   
 
 22106  8 
                     root_0 = (Object)adaptor.nil();
 22107   
                     // 594:51: -> ^( ISLITERAL expression )
 22108   
                     {
 22109   
                         // com\\googlecode\\sparkleg\\Sparql.g:594:54: ^( ISLITERAL expression )
 22110   
                         {
 22111  8 
                         Object root_1 = (Object)adaptor.nil();
 22112  8 
                         root_1 = (Object)adaptor.becomeRoot(
 22113   
                         stream_ISLITERAL.nextNode()
 22114   
                         , root_1);
 22115   
 
 22116  8 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22117   
 
 22118  8 
                         adaptor.addChild(root_0, root_1);
 22119   
                         }
 22120   
 
 22121   
                     }
 22122   
 
 22123   
 
 22124  8 
                     retval.tree = root_0;
 22125   
 
 22126   
                     }
 22127  8 
                     break;
 22128   
                 case 51 :
 22129   
                     // com\\googlecode\\sparkleg\\Sparql.g:595:7: ISNUMERIC OPEN_BRACE expression CLOSE_BRACE
 22130   
                     {
 22131  4 
                     ISNUMERIC598=(Token)match(input,ISNUMERIC,FOLLOW_ISNUMERIC_in_builtInCall6196);
 22132  4 
                     stream_ISNUMERIC.add(ISNUMERIC598);
 22133   
 
 22134   
 
 22135  4 
                     OPEN_BRACE599=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_builtInCall6198);
 22136  4 
                     stream_OPEN_BRACE.add(OPEN_BRACE599);
 22137   
 
 22138   
 
 22139  4 
                     pushFollow(FOLLOW_expression_in_builtInCall6200);
 22140  4 
                     expression600=expression();
 22141   
 
 22142  4 
                     state._fsp--;
 22143   
 
 22144  4 
                     stream_expression.add(expression600.getTree());
 22145   
 
 22146  4 
                     CLOSE_BRACE601=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_builtInCall6202);
 22147  4 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE601);
 22148   
 
 22149   
 
 22150   
                     // AST REWRITE
 22151   
                     // elements: ISNUMERIC, expression
 22152   
                     // token labels:
 22153   
                     // rule labels: retval
 22154   
                     // token list labels:
 22155   
                     // rule list labels:
 22156   
                     // wildcard labels:
 22157  4 
                     retval.tree = root_0;
 22158  4 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22159   
 
 22160  4 
                     root_0 = (Object)adaptor.nil();
 22161   
                     // 595:51: -> ^( ISNUMERIC expression )
 22162   
                     {
 22163   
                         // com\\googlecode\\sparkleg\\Sparql.g:595:54: ^( ISNUMERIC expression )
 22164   
                         {
 22165  4 
                         Object root_1 = (Object)adaptor.nil();
 22166  4 
                         root_1 = (Object)adaptor.becomeRoot(
 22167   
                         stream_ISNUMERIC.nextNode()
 22168   
                         , root_1);
 22169   
 
 22170  4 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 22171   
 
 22172  4 
                         adaptor.addChild(root_0, root_1);
 22173   
                         }
 22174   
 
 22175   
                     }
 22176   
 
 22177   
 
 22178  4 
                     retval.tree = root_0;
 22179   
 
 22180   
                     }
 22181  4 
                     break;
 22182   
                 case 52 :
 22183   
                     // com\\googlecode\\sparkleg\\Sparql.g:596:7: regexExpression
 22184   
                     {
 22185  42 
                     pushFollow(FOLLOW_regexExpression_in_builtInCall6218);
 22186  42 
                     regexExpression602=regexExpression();
 22187   
 
 22188  42 
                     state._fsp--;
 22189   
 
 22190  42 
                     stream_regexExpression.add(regexExpression602.getTree());
 22191   
 
 22192   
                     // AST REWRITE
 22193   
                     // elements: regexExpression
 22194   
                     // token labels:
 22195   
                     // rule labels: retval
 22196   
                     // token list labels:
 22197   
                     // rule list labels:
 22198   
                     // wildcard labels:
 22199  42 
                     retval.tree = root_0;
 22200  42 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22201   
 
 22202  42 
                     root_0 = (Object)adaptor.nil();
 22203   
                     // 596:23: -> regexExpression
 22204   
                     {
 22205  42 
                         adaptor.addChild(root_0, stream_regexExpression.nextTree());
 22206   
 
 22207   
                     }
 22208   
 
 22209   
 
 22210  42 
                     retval.tree = root_0;
 22211   
 
 22212   
                     }
 22213  42 
                     break;
 22214   
                 case 53 :
 22215   
                     // com\\googlecode\\sparkleg\\Sparql.g:597:7: existsFunction
 22216   
                     {
 22217  20 
                     pushFollow(FOLLOW_existsFunction_in_builtInCall6230);
 22218  20 
                     existsFunction603=existsFunction();
 22219   
 
 22220  20 
                     state._fsp--;
 22221   
 
 22222  20 
                     stream_existsFunction.add(existsFunction603.getTree());
 22223   
 
 22224   
                     // AST REWRITE
 22225   
                     // elements: existsFunction
 22226   
                     // token labels:
 22227   
                     // rule labels: retval
 22228   
                     // token list labels:
 22229   
                     // rule list labels:
 22230   
                     // wildcard labels:
 22231  20 
                     retval.tree = root_0;
 22232  20 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22233   
 
 22234  20 
                     root_0 = (Object)adaptor.nil();
 22235   
                     // 597:22: -> existsFunction
 22236   
                     {
 22237  20 
                         adaptor.addChild(root_0, stream_existsFunction.nextTree());
 22238   
 
 22239   
                     }
 22240   
 
 22241   
 
 22242  20 
                     retval.tree = root_0;
 22243   
 
 22244   
                     }
 22245  20 
                     break;
 22246   
                 case 54 :
 22247   
                     // com\\googlecode\\sparkleg\\Sparql.g:598:7: notExistsFunction
 22248   
                     {
 22249  46 
                     pushFollow(FOLLOW_notExistsFunction_in_builtInCall6242);
 22250  46 
                     notExistsFunction604=notExistsFunction();
 22251   
 
 22252  46 
                     state._fsp--;
 22253   
 
 22254  46 
                     stream_notExistsFunction.add(notExistsFunction604.getTree());
 22255   
 
 22256   
                     // AST REWRITE
 22257   
                     // elements: notExistsFunction
 22258   
                     // token labels:
 22259   
                     // rule labels: retval
 22260   
                     // token list labels:
 22261   
                     // rule list labels:
 22262   
                     // wildcard labels:
 22263  46 
                     retval.tree = root_0;
 22264  46 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22265   
 
 22266  46 
                     root_0 = (Object)adaptor.nil();
 22267   
                     // 598:25: -> notExistsFunction
 22268   
                     {
 22269  46 
                         adaptor.addChild(root_0, stream_notExistsFunction.nextTree());
 22270   
 
 22271   
                     }
 22272   
 
 22273   
 
 22274  46 
                     retval.tree = root_0;
 22275   
 
 22276   
                     }
 22277   
                     break;
 22278   
 
 22279   
             }
 22280  532 
             retval.stop = input.LT(-1);
 22281   
 
 22282   
 
 22283  532 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22284  532 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22285   
 
 22286   
         }
 22287  0 
         catch (RecognitionException re) {
 22288  0 
             reportError(re);
 22289  0 
             recover(input,re);
 22290  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22291   
 
 22292   
         }
 22293   
 
 22294  0 
         finally {
 22295   
                 // do for sure before leaving
 22296  532 
         }
 22297  532 
         return retval;
 22298   
     }
 22299   
     // $ANTLR end "builtInCall"
 22300   
 
 22301   
 
 22302  42 
     public static class regexExpression_return extends ParserRuleReturnScope {
 22303   
         Object tree;
 22304  42 
         public Object getTree() { return tree; }
 22305   
     };
 22306   
 
 22307   
 
 22308   
     // $ANTLR start "regexExpression"
 22309   
     // com\\googlecode\\sparkleg\\Sparql.g:601:1: regexExpression : REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) ;
 22310   
     public final SparqlParser.regexExpression_return regexExpression() throws RecognitionException {
 22311  42 
         SparqlParser.regexExpression_return retval = new SparqlParser.regexExpression_return();
 22312  42 
         retval.start = input.LT(1);
 22313   
 
 22314   
 
 22315  42 
         Object root_0 = null;
 22316   
 
 22317  42 
         Token REGEX605=null;
 22318  42 
         Token OPEN_BRACE606=null;
 22319  42 
         Token COMMA608=null;
 22320  42 
         Token COMMA610=null;
 22321  42 
         Token CLOSE_BRACE612=null;
 22322  42 
         SparqlParser.expression_return expression607 =null;
 22323   
 
 22324  42 
         SparqlParser.expression_return expression609 =null;
 22325   
 
 22326  42 
         SparqlParser.expression_return expression611 =null;
 22327   
 
 22328   
 
 22329  42 
         Object REGEX605_tree=null;
 22330  42 
         Object OPEN_BRACE606_tree=null;
 22331  42 
         Object COMMA608_tree=null;
 22332  42 
         Object COMMA610_tree=null;
 22333  42 
         Object CLOSE_BRACE612_tree=null;
 22334  42 
         RewriteRuleTokenStream stream_REGEX=new RewriteRuleTokenStream(adaptor,"token REGEX");
 22335  42 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22336  42 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22337  42 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22338  42 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22339   
         try {
 22340   
             // com\\googlecode\\sparkleg\\Sparql.g:602:5: ( REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( REGEX ( expression )* ) )
 22341   
             // com\\googlecode\\sparkleg\\Sparql.g:602:7: REGEX OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22342   
             {
 22343  42 
             REGEX605=(Token)match(input,REGEX,FOLLOW_REGEX_in_regexExpression6263);
 22344  42 
             stream_REGEX.add(REGEX605);
 22345   
 
 22346   
 
 22347  42 
             OPEN_BRACE606=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_regexExpression6265);
 22348  42 
             stream_OPEN_BRACE.add(OPEN_BRACE606);
 22349   
 
 22350   
 
 22351  42 
             pushFollow(FOLLOW_expression_in_regexExpression6267);
 22352  42 
             expression607=expression();
 22353   
 
 22354  42 
             state._fsp--;
 22355   
 
 22356  42 
             stream_expression.add(expression607.getTree());
 22357   
 
 22358  42 
             COMMA608=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6269);
 22359  42 
             stream_COMMA.add(COMMA608);
 22360   
 
 22361   
 
 22362  42 
             pushFollow(FOLLOW_expression_in_regexExpression6271);
 22363  42 
             expression609=expression();
 22364   
 
 22365  42 
             state._fsp--;
 22366   
 
 22367  42 
             stream_expression.add(expression609.getTree());
 22368   
 
 22369   
             // com\\googlecode\\sparkleg\\Sparql.g:602:52: ( COMMA expression )?
 22370  42 
             int alt127=2;
 22371  42 
             switch ( input.LA(1) ) {
 22372   
                 case COMMA:
 22373   
                     {
 22374  12 
                     alt127=1;
 22375   
                     }
 22376   
                     break;
 22377   
             }
 22378   
 
 22379  42 
             switch (alt127) {
 22380   
                 case 1 :
 22381   
                     // com\\googlecode\\sparkleg\\Sparql.g:602:53: COMMA expression
 22382   
                     {
 22383  12 
                     COMMA610=(Token)match(input,COMMA,FOLLOW_COMMA_in_regexExpression6274);
 22384  12 
                     stream_COMMA.add(COMMA610);
 22385   
 
 22386   
 
 22387  12 
                     pushFollow(FOLLOW_expression_in_regexExpression6276);
 22388  12 
                     expression611=expression();
 22389   
 
 22390  12 
                     state._fsp--;
 22391   
 
 22392  12 
                     stream_expression.add(expression611.getTree());
 22393   
 
 22394   
                     }
 22395   
                     break;
 22396   
 
 22397   
             }
 22398   
 
 22399   
 
 22400  42 
             CLOSE_BRACE612=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_regexExpression6280);
 22401  42 
             stream_CLOSE_BRACE.add(CLOSE_BRACE612);
 22402   
 
 22403   
 
 22404   
             // AST REWRITE
 22405   
             // elements: REGEX, expression
 22406   
             // token labels:
 22407   
             // rule labels: retval
 22408   
             // token list labels:
 22409   
             // rule list labels:
 22410   
             // wildcard labels:
 22411  42 
             retval.tree = root_0;
 22412  42 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22413   
 
 22414  42 
             root_0 = (Object)adaptor.nil();
 22415   
             // 602:84: -> ^( REGEX ( expression )* )
 22416   
             {
 22417   
                 // com\\googlecode\\sparkleg\\Sparql.g:602:87: ^( REGEX ( expression )* )
 22418   
                 {
 22419  42 
                 Object root_1 = (Object)adaptor.nil();
 22420  42 
                 root_1 = (Object)adaptor.becomeRoot(
 22421   
                 stream_REGEX.nextNode()
 22422   
                 , root_1);
 22423   
 
 22424   
                 // com\\googlecode\\sparkleg\\Sparql.g:602:95: ( expression )*
 22425  138 
                 while ( stream_expression.hasNext() ) {
 22426  96 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22427   
 
 22428   
                 }
 22429  42 
                 stream_expression.reset();
 22430   
 
 22431  42 
                 adaptor.addChild(root_0, root_1);
 22432   
                 }
 22433   
 
 22434   
             }
 22435   
 
 22436   
 
 22437  42 
             retval.tree = root_0;
 22438   
 
 22439   
             }
 22440   
 
 22441  42 
             retval.stop = input.LT(-1);
 22442   
 
 22443   
 
 22444  42 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22445  42 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22446   
 
 22447   
         }
 22448  0 
         catch (RecognitionException re) {
 22449  0 
             reportError(re);
 22450  0 
             recover(input,re);
 22451  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22452   
 
 22453   
         }
 22454   
 
 22455  0 
         finally {
 22456   
                 // do for sure before leaving
 22457  42 
         }
 22458  42 
         return retval;
 22459   
     }
 22460   
     // $ANTLR end "regexExpression"
 22461   
 
 22462   
 
 22463  4 
     public static class subStringExpression_return extends ParserRuleReturnScope {
 22464   
         Object tree;
 22465  4 
         public Object getTree() { return tree; }
 22466   
     };
 22467   
 
 22468   
 
 22469   
     // $ANTLR start "subStringExpression"
 22470   
     // com\\googlecode\\sparkleg\\Sparql.g:605:1: subStringExpression : SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) ;
 22471   
     public final SparqlParser.subStringExpression_return subStringExpression() throws RecognitionException {
 22472  4 
         SparqlParser.subStringExpression_return retval = new SparqlParser.subStringExpression_return();
 22473  4 
         retval.start = input.LT(1);
 22474   
 
 22475   
 
 22476  4 
         Object root_0 = null;
 22477   
 
 22478  4 
         Token SUBSTR613=null;
 22479  4 
         Token OPEN_BRACE614=null;
 22480  4 
         Token COMMA616=null;
 22481  4 
         Token COMMA618=null;
 22482  4 
         Token CLOSE_BRACE620=null;
 22483  4 
         SparqlParser.expression_return expression615 =null;
 22484   
 
 22485  4 
         SparqlParser.expression_return expression617 =null;
 22486   
 
 22487  4 
         SparqlParser.expression_return expression619 =null;
 22488   
 
 22489   
 
 22490  4 
         Object SUBSTR613_tree=null;
 22491  4 
         Object OPEN_BRACE614_tree=null;
 22492  4 
         Object COMMA616_tree=null;
 22493  4 
         Object COMMA618_tree=null;
 22494  4 
         Object CLOSE_BRACE620_tree=null;
 22495  4 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22496  4 
         RewriteRuleTokenStream stream_SUBSTR=new RewriteRuleTokenStream(adaptor,"token SUBSTR");
 22497  4 
         RewriteRuleTokenStream stream_COMMA=new RewriteRuleTokenStream(adaptor,"token COMMA");
 22498  4 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22499  4 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22500   
         try {
 22501   
             // com\\googlecode\\sparkleg\\Sparql.g:606:5: ( SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE -> ^( SUBSTR ( expression )* ) )
 22502   
             // com\\googlecode\\sparkleg\\Sparql.g:606:7: SUBSTR OPEN_BRACE expression COMMA expression ( COMMA expression )? CLOSE_BRACE
 22503   
             {
 22504  4 
             SUBSTR613=(Token)match(input,SUBSTR,FOLLOW_SUBSTR_in_subStringExpression6310);
 22505  4 
             stream_SUBSTR.add(SUBSTR613);
 22506   
 
 22507   
 
 22508  4 
             OPEN_BRACE614=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_subStringExpression6312);
 22509  4 
             stream_OPEN_BRACE.add(OPEN_BRACE614);
 22510   
 
 22511   
 
 22512  4 
             pushFollow(FOLLOW_expression_in_subStringExpression6314);
 22513  4 
             expression615=expression();
 22514   
 
 22515  4 
             state._fsp--;
 22516   
 
 22517  4 
             stream_expression.add(expression615.getTree());
 22518   
 
 22519  4 
             COMMA616=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6316);
 22520  4 
             stream_COMMA.add(COMMA616);
 22521   
 
 22522   
 
 22523  4 
             pushFollow(FOLLOW_expression_in_subStringExpression6318);
 22524  4 
             expression617=expression();
 22525   
 
 22526  4 
             state._fsp--;
 22527   
 
 22528  4 
             stream_expression.add(expression617.getTree());
 22529   
 
 22530   
             // com\\googlecode\\sparkleg\\Sparql.g:606:53: ( COMMA expression )?
 22531  4 
             int alt128=2;
 22532  4 
             switch ( input.LA(1) ) {
 22533   
                 case COMMA:
 22534   
                     {
 22535  2 
                     alt128=1;
 22536   
                     }
 22537   
                     break;
 22538   
             }
 22539   
 
 22540  4 
             switch (alt128) {
 22541   
                 case 1 :
 22542   
                     // com\\googlecode\\sparkleg\\Sparql.g:606:54: COMMA expression
 22543   
                     {
 22544  2 
                     COMMA618=(Token)match(input,COMMA,FOLLOW_COMMA_in_subStringExpression6321);
 22545  2 
                     stream_COMMA.add(COMMA618);
 22546   
 
 22547   
 
 22548  2 
                     pushFollow(FOLLOW_expression_in_subStringExpression6323);
 22549  2 
                     expression619=expression();
 22550   
 
 22551  2 
                     state._fsp--;
 22552   
 
 22553  2 
                     stream_expression.add(expression619.getTree());
 22554   
 
 22555   
                     }
 22556   
                     break;
 22557   
 
 22558   
             }
 22559   
 
 22560   
 
 22561  4 
             CLOSE_BRACE620=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_subStringExpression6327);
 22562  4 
             stream_CLOSE_BRACE.add(CLOSE_BRACE620);
 22563   
 
 22564   
 
 22565   
             // AST REWRITE
 22566   
             // elements: expression, SUBSTR
 22567   
             // token labels:
 22568   
             // rule labels: retval
 22569   
             // token list labels:
 22570   
             // rule list labels:
 22571   
             // wildcard labels:
 22572  4 
             retval.tree = root_0;
 22573  4 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22574   
 
 22575  4 
             root_0 = (Object)adaptor.nil();
 22576   
             // 606:85: -> ^( SUBSTR ( expression )* )
 22577   
             {
 22578   
                 // com\\googlecode\\sparkleg\\Sparql.g:606:88: ^( SUBSTR ( expression )* )
 22579   
                 {
 22580  4 
                 Object root_1 = (Object)adaptor.nil();
 22581  4 
                 root_1 = (Object)adaptor.becomeRoot(
 22582   
                 stream_SUBSTR.nextNode()
 22583   
                 , root_1);
 22584   
 
 22585   
                 // com\\googlecode\\sparkleg\\Sparql.g:606:97: ( expression )*
 22586  14 
                 while ( stream_expression.hasNext() ) {
 22587  10 
                     adaptor.addChild(root_1, stream_expression.nextTree());
 22588   
 
 22589   
                 }
 22590  4 
                 stream_expression.reset();
 22591   
 
 22592  4 
                 adaptor.addChild(root_0, root_1);
 22593   
                 }
 22594   
 
 22595   
             }
 22596   
 
 22597   
 
 22598  4 
             retval.tree = root_0;
 22599   
 
 22600   
             }
 22601   
 
 22602  4 
             retval.stop = input.LT(-1);
 22603   
 
 22604   
 
 22605  4 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22606  4 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22607   
 
 22608   
         }
 22609  0 
         catch (RecognitionException re) {
 22610  0 
             reportError(re);
 22611  0 
             recover(input,re);
 22612  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22613   
 
 22614   
         }
 22615   
 
 22616  0 
         finally {
 22617   
                 // do for sure before leaving
 22618  4 
         }
 22619  4 
         return retval;
 22620   
     }
 22621   
     // $ANTLR end "subStringExpression"
 22622   
 
 22623   
 
 22624  20 
     public static class existsFunction_return extends ParserRuleReturnScope {
 22625   
         Object tree;
 22626  20 
         public Object getTree() { return tree; }
 22627   
     };
 22628   
 
 22629   
 
 22630   
     // $ANTLR start "existsFunction"
 22631   
     // com\\googlecode\\sparkleg\\Sparql.g:609:1: existsFunction : EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) ;
 22632   
     public final SparqlParser.existsFunction_return existsFunction() throws RecognitionException {
 22633  20 
         SparqlParser.existsFunction_return retval = new SparqlParser.existsFunction_return();
 22634  20 
         retval.start = input.LT(1);
 22635   
 
 22636   
 
 22637  20 
         Object root_0 = null;
 22638   
 
 22639  20 
         Token EXISTS621=null;
 22640  20 
         SparqlParser.groupGraphPattern_return groupGraphPattern622 =null;
 22641   
 
 22642   
 
 22643  20 
         Object EXISTS621_tree=null;
 22644  20 
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22645  20 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22646   
         try {
 22647   
             // com\\googlecode\\sparkleg\\Sparql.g:610:5: ( EXISTS groupGraphPattern -> ^( EXISTS groupGraphPattern ) )
 22648   
             // com\\googlecode\\sparkleg\\Sparql.g:610:7: EXISTS groupGraphPattern
 22649   
             {
 22650  20 
             EXISTS621=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_existsFunction6357);
 22651  20 
             stream_EXISTS.add(EXISTS621);
 22652   
 
 22653   
 
 22654  20 
             pushFollow(FOLLOW_groupGraphPattern_in_existsFunction6359);
 22655  20 
             groupGraphPattern622=groupGraphPattern();
 22656   
 
 22657  20 
             state._fsp--;
 22658   
 
 22659  20 
             stream_groupGraphPattern.add(groupGraphPattern622.getTree());
 22660   
 
 22661   
             // AST REWRITE
 22662   
             // elements: groupGraphPattern, EXISTS
 22663   
             // token labels:
 22664   
             // rule labels: retval
 22665   
             // token list labels:
 22666   
             // rule list labels:
 22667   
             // wildcard labels:
 22668  20 
             retval.tree = root_0;
 22669  20 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22670   
 
 22671  20 
             root_0 = (Object)adaptor.nil();
 22672   
             // 610:32: -> ^( EXISTS groupGraphPattern )
 22673   
             {
 22674   
                 // com\\googlecode\\sparkleg\\Sparql.g:610:35: ^( EXISTS groupGraphPattern )
 22675   
                 {
 22676  20 
                 Object root_1 = (Object)adaptor.nil();
 22677  20 
                 root_1 = (Object)adaptor.becomeRoot(
 22678   
                 stream_EXISTS.nextNode()
 22679   
                 , root_1);
 22680   
 
 22681  20 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22682   
 
 22683  20 
                 adaptor.addChild(root_0, root_1);
 22684   
                 }
 22685   
 
 22686   
             }
 22687   
 
 22688   
 
 22689  20 
             retval.tree = root_0;
 22690   
 
 22691   
             }
 22692   
 
 22693  20 
             retval.stop = input.LT(-1);
 22694   
 
 22695   
 
 22696  20 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22697  20 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22698   
 
 22699   
         }
 22700  0 
         catch (RecognitionException re) {
 22701  0 
             reportError(re);
 22702  0 
             recover(input,re);
 22703  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22704   
 
 22705   
         }
 22706   
 
 22707  0 
         finally {
 22708   
                 // do for sure before leaving
 22709  20 
         }
 22710  20 
         return retval;
 22711   
     }
 22712   
     // $ANTLR end "existsFunction"
 22713   
 
 22714   
 
 22715  46 
     public static class notExistsFunction_return extends ParserRuleReturnScope {
 22716   
         Object tree;
 22717  46 
         public Object getTree() { return tree; }
 22718   
     };
 22719   
 
 22720   
 
 22721   
     // $ANTLR start "notExistsFunction"
 22722   
     // com\\googlecode\\sparkleg\\Sparql.g:613:1: notExistsFunction : NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) ;
 22723   
     public final SparqlParser.notExistsFunction_return notExistsFunction() throws RecognitionException {
 22724  46 
         SparqlParser.notExistsFunction_return retval = new SparqlParser.notExistsFunction_return();
 22725  46 
         retval.start = input.LT(1);
 22726   
 
 22727   
 
 22728  46 
         Object root_0 = null;
 22729   
 
 22730  46 
         Token NOT623=null;
 22731  46 
         Token EXISTS624=null;
 22732  46 
         SparqlParser.groupGraphPattern_return groupGraphPattern625 =null;
 22733   
 
 22734   
 
 22735  46 
         Object NOT623_tree=null;
 22736  46 
         Object EXISTS624_tree=null;
 22737  46 
         RewriteRuleTokenStream stream_NOT=new RewriteRuleTokenStream(adaptor,"token NOT");
 22738  46 
         RewriteRuleTokenStream stream_EXISTS=new RewriteRuleTokenStream(adaptor,"token EXISTS");
 22739  46 
         RewriteRuleSubtreeStream stream_groupGraphPattern=new RewriteRuleSubtreeStream(adaptor,"rule groupGraphPattern");
 22740   
         try {
 22741   
             // com\\googlecode\\sparkleg\\Sparql.g:614:5: ( NOT EXISTS groupGraphPattern -> ^( NOT_EXISTS groupGraphPattern ) )
 22742   
             // com\\googlecode\\sparkleg\\Sparql.g:614:7: NOT EXISTS groupGraphPattern
 22743   
             {
 22744  46 
             NOT623=(Token)match(input,NOT,FOLLOW_NOT_in_notExistsFunction6384);
 22745  46 
             stream_NOT.add(NOT623);
 22746   
 
 22747   
 
 22748  46 
             EXISTS624=(Token)match(input,EXISTS,FOLLOW_EXISTS_in_notExistsFunction6386);
 22749  46 
             stream_EXISTS.add(EXISTS624);
 22750   
 
 22751   
 
 22752  46 
             pushFollow(FOLLOW_groupGraphPattern_in_notExistsFunction6388);
 22753  46 
             groupGraphPattern625=groupGraphPattern();
 22754   
 
 22755  46 
             state._fsp--;
 22756   
 
 22757  46 
             stream_groupGraphPattern.add(groupGraphPattern625.getTree());
 22758   
 
 22759   
             // AST REWRITE
 22760   
             // elements: groupGraphPattern
 22761   
             // token labels:
 22762   
             // rule labels: retval
 22763   
             // token list labels:
 22764   
             // rule list labels:
 22765   
             // wildcard labels:
 22766  46 
             retval.tree = root_0;
 22767  46 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 22768   
 
 22769  46 
             root_0 = (Object)adaptor.nil();
 22770   
             // 614:36: -> ^( NOT_EXISTS groupGraphPattern )
 22771   
             {
 22772   
                 // com\\googlecode\\sparkleg\\Sparql.g:614:39: ^( NOT_EXISTS groupGraphPattern )
 22773   
                 {
 22774  46 
                 Object root_1 = (Object)adaptor.nil();
 22775  46 
                 root_1 = (Object)adaptor.becomeRoot(
 22776   
                 (Object)adaptor.create(NOT_EXISTS, "NOT_EXISTS")
 22777   
                 , root_1);
 22778   
 
 22779  46 
                 adaptor.addChild(root_1, stream_groupGraphPattern.nextTree());
 22780   
 
 22781  46 
                 adaptor.addChild(root_0, root_1);
 22782   
                 }
 22783   
 
 22784   
             }
 22785   
 
 22786   
 
 22787  46 
             retval.tree = root_0;
 22788   
 
 22789   
             }
 22790   
 
 22791  46 
             retval.stop = input.LT(-1);
 22792   
 
 22793   
 
 22794  46 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 22795  46 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 22796   
 
 22797   
         }
 22798  0 
         catch (RecognitionException re) {
 22799  0 
             reportError(re);
 22800  0 
             recover(input,re);
 22801  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 22802   
 
 22803   
         }
 22804   
 
 22805  0 
         finally {
 22806   
                 // do for sure before leaving
 22807  46 
         }
 22808  46 
         return retval;
 22809   
     }
 22810   
     // $ANTLR end "notExistsFunction"
 22811   
 
 22812   
 
 22813  106 
     public static class aggregate_return extends ParserRuleReturnScope {
 22814   
         Object tree;
 22815  106 
         public Object getTree() { return tree; }
 22816   
     };
 22817   
 
 22818   
 
 22819   
     // $ANTLR start "aggregate"
 22820   
     // com\\googlecode\\sparkleg\\Sparql.g:617:1: aggregate : ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) );
 22821   
     public final SparqlParser.aggregate_return aggregate() throws RecognitionException {
 22822  106 
         SparqlParser.aggregate_return retval = new SparqlParser.aggregate_return();
 22823  106 
         retval.start = input.LT(1);
 22824   
 
 22825   
 
 22826  106 
         Object root_0 = null;
 22827   
 
 22828  106 
         Token COUNT626=null;
 22829  106 
         Token OPEN_BRACE627=null;
 22830  106 
         Token DISTINCT628=null;
 22831  106 
         Token ASTERISK629=null;
 22832  106 
         Token CLOSE_BRACE631=null;
 22833  106 
         Token SUM632=null;
 22834  106 
         Token OPEN_BRACE633=null;
 22835  106 
         Token DISTINCT634=null;
 22836  106 
         Token CLOSE_BRACE636=null;
 22837  106 
         Token MIN637=null;
 22838  106 
         Token OPEN_BRACE638=null;
 22839  106 
         Token DISTINCT639=null;
 22840  106 
         Token CLOSE_BRACE641=null;
 22841  106 
         Token MAX642=null;
 22842  106 
         Token OPEN_BRACE643=null;
 22843  106 
         Token DISTINCT644=null;
 22844  106 
         Token CLOSE_BRACE646=null;
 22845  106 
         Token AVG647=null;
 22846  106 
         Token OPEN_BRACE648=null;
 22847  106 
         Token DISTINCT649=null;
 22848  106 
         Token CLOSE_BRACE651=null;
 22849  106 
         Token SAMPLE652=null;
 22850  106 
         Token OPEN_BRACE653=null;
 22851  106 
         Token DISTINCT654=null;
 22852  106 
         Token CLOSE_BRACE656=null;
 22853  106 
         Token GROUP_CONCAT657=null;
 22854  106 
         Token OPEN_BRACE658=null;
 22855  106 
         Token DISTINCT659=null;
 22856  106 
         Token SEMICOLON661=null;
 22857  106 
         Token SEPARATOR662=null;
 22858  106 
         Token EQUAL663=null;
 22859  106 
         Token CLOSE_BRACE665=null;
 22860  106 
         SparqlParser.expression_return expression630 =null;
 22861   
 
 22862  106 
         SparqlParser.expression_return expression635 =null;
 22863   
 
 22864  106 
         SparqlParser.expression_return expression640 =null;
 22865   
 
 22866  106 
         SparqlParser.expression_return expression645 =null;
 22867   
 
 22868  106 
         SparqlParser.expression_return expression650 =null;
 22869   
 
 22870  106 
         SparqlParser.expression_return expression655 =null;
 22871   
 
 22872  106 
         SparqlParser.expression_return expression660 =null;
 22873   
 
 22874  106 
         SparqlParser.string_return string664 =null;
 22875   
 
 22876   
 
 22877  106 
         Object COUNT626_tree=null;
 22878  106 
         Object OPEN_BRACE627_tree=null;
 22879  106 
         Object DISTINCT628_tree=null;
 22880  106 
         Object ASTERISK629_tree=null;
 22881  106 
         Object CLOSE_BRACE631_tree=null;
 22882  106 
         Object SUM632_tree=null;
 22883  106 
         Object OPEN_BRACE633_tree=null;
 22884  106 
         Object DISTINCT634_tree=null;
 22885  106 
         Object CLOSE_BRACE636_tree=null;
 22886  106 
         Object MIN637_tree=null;
 22887  106 
         Object OPEN_BRACE638_tree=null;
 22888  106 
         Object DISTINCT639_tree=null;
 22889  106 
         Object CLOSE_BRACE641_tree=null;
 22890  106 
         Object MAX642_tree=null;
 22891  106 
         Object OPEN_BRACE643_tree=null;
 22892  106 
         Object DISTINCT644_tree=null;
 22893  106 
         Object CLOSE_BRACE646_tree=null;
 22894  106 
         Object AVG647_tree=null;
 22895  106 
         Object OPEN_BRACE648_tree=null;
 22896  106 
         Object DISTINCT649_tree=null;
 22897  106 
         Object CLOSE_BRACE651_tree=null;
 22898  106 
         Object SAMPLE652_tree=null;
 22899  106 
         Object OPEN_BRACE653_tree=null;
 22900  106 
         Object DISTINCT654_tree=null;
 22901  106 
         Object CLOSE_BRACE656_tree=null;
 22902  106 
         Object GROUP_CONCAT657_tree=null;
 22903  106 
         Object OPEN_BRACE658_tree=null;
 22904  106 
         Object DISTINCT659_tree=null;
 22905  106 
         Object SEMICOLON661_tree=null;
 22906  106 
         Object SEPARATOR662_tree=null;
 22907  106 
         Object EQUAL663_tree=null;
 22908  106 
         Object CLOSE_BRACE665_tree=null;
 22909  106 
         RewriteRuleTokenStream stream_SAMPLE=new RewriteRuleTokenStream(adaptor,"token SAMPLE");
 22910  106 
         RewriteRuleTokenStream stream_AVG=new RewriteRuleTokenStream(adaptor,"token AVG");
 22911  106 
         RewriteRuleTokenStream stream_EQUAL=new RewriteRuleTokenStream(adaptor,"token EQUAL");
 22912  106 
         RewriteRuleTokenStream stream_GROUP_CONCAT=new RewriteRuleTokenStream(adaptor,"token GROUP_CONCAT");
 22913  106 
         RewriteRuleTokenStream stream_MAX=new RewriteRuleTokenStream(adaptor,"token MAX");
 22914  106 
         RewriteRuleTokenStream stream_COUNT=new RewriteRuleTokenStream(adaptor,"token COUNT");
 22915  106 
         RewriteRuleTokenStream stream_SEMICOLON=new RewriteRuleTokenStream(adaptor,"token SEMICOLON");
 22916  106 
         RewriteRuleTokenStream stream_SEPARATOR=new RewriteRuleTokenStream(adaptor,"token SEPARATOR");
 22917  106 
         RewriteRuleTokenStream stream_CLOSE_BRACE=new RewriteRuleTokenStream(adaptor,"token CLOSE_BRACE");
 22918  106 
         RewriteRuleTokenStream stream_MIN=new RewriteRuleTokenStream(adaptor,"token MIN");
 22919  106 
         RewriteRuleTokenStream stream_SUM=new RewriteRuleTokenStream(adaptor,"token SUM");
 22920  106 
         RewriteRuleTokenStream stream_DISTINCT=new RewriteRuleTokenStream(adaptor,"token DISTINCT");
 22921  106 
         RewriteRuleTokenStream stream_OPEN_BRACE=new RewriteRuleTokenStream(adaptor,"token OPEN_BRACE");
 22922  106 
         RewriteRuleTokenStream stream_ASTERISK=new RewriteRuleTokenStream(adaptor,"token ASTERISK");
 22923  106 
         RewriteRuleSubtreeStream stream_expression=new RewriteRuleSubtreeStream(adaptor,"rule expression");
 22924  106 
         RewriteRuleSubtreeStream stream_string=new RewriteRuleSubtreeStream(adaptor,"rule string");
 22925   
         try {
 22926   
             // com\\googlecode\\sparkleg\\Sparql.g:618:5: ( COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* ) | SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SUM ( DISTINCT )* expression ) | MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MIN ( DISTINCT )* expression ) | MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( MAX ( DISTINCT )* expression ) | AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( AVG ( DISTINCT )* expression ) | SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE -> ^( SAMPLE ( DISTINCT )? expression ) | GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* ) )
 22927  106 
             int alt138=7;
 22928  106 
             switch ( input.LA(1) ) {
 22929   
             case COUNT:
 22930   
                 {
 22931  34 
                 alt138=1;
 22932   
                 }
 22933  34 
                 break;
 22934   
             case SUM:
 22935   
                 {
 22936  12 
                 alt138=2;
 22937   
                 }
 22938  12 
                 break;
 22939   
             case MIN:
 22940   
                 {
 22941  14 
                 alt138=3;
 22942   
                 }
 22943  14 
                 break;
 22944   
             case MAX:
 22945   
                 {
 22946  10 
                 alt138=4;
 22947   
                 }
 22948  10 
                 break;
 22949   
             case AVG:
 22950   
                 {
 22951  24 
                 alt138=5;
 22952   
                 }
 22953  24 
                 break;
 22954   
             case SAMPLE:
 22955   
                 {
 22956  6 
                 alt138=6;
 22957   
                 }
 22958  6 
                 break;
 22959   
             case GROUP_CONCAT:
 22960   
                 {
 22961  6 
                 alt138=7;
 22962   
                 }
 22963  6 
                 break;
 22964   
             default:
 22965  0 
                 NoViableAltException nvae =
 22966   
                     new NoViableAltException("", 138, 0, input);
 22967   
 
 22968  0 
                 throw nvae;
 22969   
 
 22970   
             }
 22971   
 
 22972  106 
             switch (alt138) {
 22973   
                 case 1 :
 22974   
                     // com\\googlecode\\sparkleg\\Sparql.g:618:7: COUNT OPEN_BRACE ( DISTINCT )? ( ASTERISK | expression ) CLOSE_BRACE
 22975   
                     {
 22976  34 
                     COUNT626=(Token)match(input,COUNT,FOLLOW_COUNT_in_aggregate6413);
 22977  34 
                     stream_COUNT.add(COUNT626);
 22978   
 
 22979   
 
 22980  34 
                     OPEN_BRACE627=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6415);
 22981  34 
                     stream_OPEN_BRACE.add(OPEN_BRACE627);
 22982   
 
 22983   
 
 22984   
                     // com\\googlecode\\sparkleg\\Sparql.g:618:24: ( DISTINCT )?
 22985  34 
                     int alt129=2;
 22986  34 
                     switch ( input.LA(1) ) {
 22987   
                         case DISTINCT:
 22988   
                             {
 22989  0 
                             alt129=1;
 22990   
                             }
 22991   
                             break;
 22992   
                     }
 22993   
 
 22994  34 
                     switch (alt129) {
 22995   
                         case 1 :
 22996   
                             // com\\googlecode\\sparkleg\\Sparql.g:618:24: DISTINCT
 22997   
                             {
 22998  0 
                             DISTINCT628=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6417);
 22999  0 
                             stream_DISTINCT.add(DISTINCT628);
 23000   
 
 23001   
 
 23002   
                             }
 23003   
                             break;
 23004   
 
 23005   
                     }
 23006   
 
 23007   
 
 23008   
                     // com\\googlecode\\sparkleg\\Sparql.g:618:34: ( ASTERISK | expression )
 23009  34 
                     int alt130=2;
 23010  34 
                     switch ( input.LA(1) ) {
 23011   
                     case ASTERISK:
 23012   
                         {
 23013  14 
                         alt130=1;
 23014   
                         }
 23015  14 
                         break;
 23016   
                     case ABS:
 23017   
                     case AVG:
 23018   
                     case BNODE:
 23019   
                     case BOUND:
 23020   
                     case CEIL:
 23021   
                     case COALESCE:
 23022   
                     case CONCAT:
 23023   
                     case CONTAINS:
 23024   
                     case COUNT:
 23025   
                     case DATATYPE:
 23026   
                     case DAY:
 23027   
                     case DECIMAL:
 23028   
                     case DECIMAL_NEGATIVE:
 23029   
                     case DECIMAL_POSITIVE:
 23030   
                     case DOUBLE:
 23031   
                     case DOUBLE_NEGATIVE:
 23032   
                     case DOUBLE_POSITIVE:
 23033   
                     case ENCODE_FOR_URI:
 23034   
                     case EXISTS:
 23035   
                     case FALSE:
 23036   
                     case FLOOR:
 23037   
                     case GROUP_CONCAT:
 23038   
                     case HOURS:
 23039   
                     case IF:
 23040   
                     case INTEGER:
 23041   
                     case INTEGER_NEGATIVE:
 23042   
                     case INTEGER_POSITIVE:
 23043   
                     case IRI:
 23044   
                     case IRI_REF:
 23045   
                     case ISBLANK:
 23046   
                     case ISIRI:
 23047   
                     case ISLITERAL:
 23048   
                     case ISNUMERIC:
 23049   
                     case ISURI:
 23050   
                     case LANG:
 23051   
                     case LANGMATCHES:
 23052   
                     case LCASE:
 23053   
                     case MAX:
 23054   
                     case MD5:
 23055   
                     case MIN:
 23056   
                     case MINUS:
 23057   
                     case MINUTES:
 23058   
                     case MONTH:
 23059   
                     case NEGATION:
 23060   
                     case NOT:
 23061   
                     case NOW:
 23062   
                     case OPEN_BRACE:
 23063   
                     case PLUS:
 23064   
                     case PNAME_LN:
 23065   
                     case PNAME_NS:
 23066   
                     case RAND:
 23067   
                     case REGEX:
 23068   
                     case REPLACE:
 23069   
                     case ROUND:
 23070   
                     case SAMETERM:
 23071   
                     case SAMPLE:
 23072   
                     case SECONDS:
 23073   
                     case SHA1:
 23074   
                     case SHA224:
 23075   
                     case SHA256:
 23076   
                     case SHA384:
 23077   
                     case SHA512:
 23078   
                     case STR:
 23079   
                     case STRAFTER:
 23080   
                     case STRBEFORE:
 23081   
                     case STRDT:
 23082   
                     case STRENDS:
 23083   
                     case STRING_LITERAL1:
 23084   
                     case STRING_LITERAL2:
 23085   
                     case STRING_LITERAL_LONG1:
 23086   
                     case STRING_LITERAL_LONG2:
 23087   
                     case STRLANG:
 23088   
                     case STRLEN:
 23089   
                     case STRSTARTS:
 23090   
                     case SUBSTR:
 23091   
                     case SUM:
 23092   
                     case TIMEZONE:
 23093   
                     case TRUE:
 23094   
                     case TZ:
 23095   
                     case UCASE:
 23096   
                     case URI:
 23097   
                     case VAR1:
 23098   
                     case VAR2:
 23099   
                     case YEAR:
 23100   
                         {
 23101  20 
                         alt130=2;
 23102   
                         }
 23103  20 
                         break;
 23104   
                     default:
 23105  0 
                         NoViableAltException nvae =
 23106   
                             new NoViableAltException("", 130, 0, input);
 23107   
 
 23108  0 
                         throw nvae;
 23109   
 
 23110   
                     }
 23111   
 
 23112  34 
                     switch (alt130) {
 23113   
                         case 1 :
 23114   
                             // com\\googlecode\\sparkleg\\Sparql.g:618:35: ASTERISK
 23115   
                             {
 23116  14 
                             ASTERISK629=(Token)match(input,ASTERISK,FOLLOW_ASTERISK_in_aggregate6421);
 23117  14 
                             stream_ASTERISK.add(ASTERISK629);
 23118   
 
 23119   
 
 23120   
                             }
 23121  14 
                             break;
 23122   
                         case 2 :
 23123   
                             // com\\googlecode\\sparkleg\\Sparql.g:618:46: expression
 23124   
                             {
 23125  20 
                             pushFollow(FOLLOW_expression_in_aggregate6425);
 23126  20 
                             expression630=expression();
 23127   
 
 23128  20 
                             state._fsp--;
 23129   
 
 23130  20 
                             stream_expression.add(expression630.getTree());
 23131   
 
 23132   
                             }
 23133   
                             break;
 23134   
 
 23135   
                     }
 23136   
 
 23137   
 
 23138  34 
                     CLOSE_BRACE631=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6428);
 23139  34 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE631);
 23140   
 
 23141   
 
 23142   
                     // AST REWRITE
 23143   
                     // elements: ASTERISK, DISTINCT, COUNT, expression
 23144   
                     // token labels:
 23145   
                     // rule labels: retval
 23146   
                     // token list labels:
 23147   
                     // rule list labels:
 23148   
                     // wildcard labels:
 23149  34 
                     retval.tree = root_0;
 23150  34 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23151   
 
 23152  34 
                     root_0 = (Object)adaptor.nil();
 23153   
                     // 618:70: -> ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23154   
                     {
 23155   
                         // com\\googlecode\\sparkleg\\Sparql.g:618:73: ^( COUNT ( DISTINCT )* ( ASTERISK )* ( expression )* )
 23156   
                         {
 23157  34 
                         Object root_1 = (Object)adaptor.nil();
 23158  34 
                         root_1 = (Object)adaptor.becomeRoot(
 23159   
                         stream_COUNT.nextNode()
 23160   
                         , root_1);
 23161   
 
 23162   
                         // com\\googlecode\\sparkleg\\Sparql.g:618:81: ( DISTINCT )*
 23163  34 
                         while ( stream_DISTINCT.hasNext() ) {
 23164  0 
                             adaptor.addChild(root_1,
 23165   
                             stream_DISTINCT.nextNode()
 23166   
                             );
 23167   
 
 23168   
                         }
 23169  34 
                         stream_DISTINCT.reset();
 23170   
 
 23171   
                         // com\\googlecode\\sparkleg\\Sparql.g:618:91: ( ASTERISK )*
 23172  48 
                         while ( stream_ASTERISK.hasNext() ) {
 23173  14 
                             adaptor.addChild(root_1,
 23174   
                             stream_ASTERISK.nextNode()
 23175   
                             );
 23176   
 
 23177   
                         }
 23178  34 
                         stream_ASTERISK.reset();
 23179   
 
 23180   
                         // com\\googlecode\\sparkleg\\Sparql.g:618:101: ( expression )*
 23181  54 
                         while ( stream_expression.hasNext() ) {
 23182  20 
                             adaptor.addChild(root_1, stream_expression.nextTree());
 23183   
 
 23184   
                         }
 23185  34 
                         stream_expression.reset();
 23186   
 
 23187  34 
                         adaptor.addChild(root_0, root_1);
 23188   
                         }
 23189   
 
 23190   
                     }
 23191   
 
 23192   
 
 23193  34 
                     retval.tree = root_0;
 23194   
 
 23195   
                     }
 23196  34 
                     break;
 23197   
                 case 2 :
 23198   
                     // com\\googlecode\\sparkleg\\Sparql.g:619:7: SUM OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23199   
                     {
 23200  12 
                     SUM632=(Token)match(input,SUM,FOLLOW_SUM_in_aggregate6451);
 23201  12 
                     stream_SUM.add(SUM632);
 23202   
 
 23203   
 
 23204  12 
                     OPEN_BRACE633=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6453);
 23205  12 
                     stream_OPEN_BRACE.add(OPEN_BRACE633);
 23206   
 
 23207   
 
 23208   
                     // com\\googlecode\\sparkleg\\Sparql.g:619:22: ( DISTINCT )?
 23209  12 
                     int alt131=2;
 23210  12 
                     switch ( input.LA(1) ) {
 23211   
                         case DISTINCT:
 23212   
                             {
 23213  0 
                             alt131=1;
 23214   
                             }
 23215   
                             break;
 23216   
                     }
 23217   
 
 23218  12 
                     switch (alt131) {
 23219   
                         case 1 :
 23220   
                             // com\\googlecode\\sparkleg\\Sparql.g:619:22: DISTINCT
 23221   
                             {
 23222  0 
                             DISTINCT634=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6455);
 23223  0 
                             stream_DISTINCT.add(DISTINCT634);
 23224   
 
 23225   
 
 23226   
                             }
 23227   
                             break;
 23228   
 
 23229   
                     }
 23230   
 
 23231   
 
 23232  12 
                     pushFollow(FOLLOW_expression_in_aggregate6458);
 23233  12 
                     expression635=expression();
 23234   
 
 23235  12 
                     state._fsp--;
 23236   
 
 23237  12 
                     stream_expression.add(expression635.getTree());
 23238   
 
 23239  12 
                     CLOSE_BRACE636=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6460);
 23240  12 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE636);
 23241   
 
 23242   
 
 23243   
                     // AST REWRITE
 23244   
                     // elements: expression, SUM, DISTINCT
 23245   
                     // token labels:
 23246   
                     // rule labels: retval
 23247   
                     // token list labels:
 23248   
                     // rule list labels:
 23249   
                     // wildcard labels:
 23250  12 
                     retval.tree = root_0;
 23251  12 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23252   
 
 23253  12 
                     root_0 = (Object)adaptor.nil();
 23254   
                     // 619:55: -> ^( SUM ( DISTINCT )* expression )
 23255   
                     {
 23256   
                         // com\\googlecode\\sparkleg\\Sparql.g:619:58: ^( SUM ( DISTINCT )* expression )
 23257   
                         {
 23258  12 
                         Object root_1 = (Object)adaptor.nil();
 23259  12 
                         root_1 = (Object)adaptor.becomeRoot(
 23260   
                         stream_SUM.nextNode()
 23261   
                         , root_1);
 23262   
 
 23263   
                         // com\\googlecode\\sparkleg\\Sparql.g:619:64: ( DISTINCT )*
 23264  12 
                         while ( stream_DISTINCT.hasNext() ) {
 23265  0 
                             adaptor.addChild(root_1,
 23266   
                             stream_DISTINCT.nextNode()
 23267   
                             );
 23268   
 
 23269   
                         }
 23270  12 
                         stream_DISTINCT.reset();
 23271   
 
 23272  12 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23273   
 
 23274  12 
                         adaptor.addChild(root_0, root_1);
 23275   
                         }
 23276   
 
 23277   
                     }
 23278   
 
 23279   
 
 23280  12 
                     retval.tree = root_0;
 23281   
 
 23282   
                     }
 23283  12 
                     break;
 23284   
                 case 3 :
 23285   
                     // com\\googlecode\\sparkleg\\Sparql.g:620:7: MIN OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23286   
                     {
 23287  14 
                     MIN637=(Token)match(input,MIN,FOLLOW_MIN_in_aggregate6479);
 23288  14 
                     stream_MIN.add(MIN637);
 23289   
 
 23290   
 
 23291  14 
                     OPEN_BRACE638=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6481);
 23292  14 
                     stream_OPEN_BRACE.add(OPEN_BRACE638);
 23293   
 
 23294   
 
 23295   
                     // com\\googlecode\\sparkleg\\Sparql.g:620:22: ( DISTINCT )?
 23296  14 
                     int alt132=2;
 23297  14 
                     switch ( input.LA(1) ) {
 23298   
                         case DISTINCT:
 23299   
                             {
 23300  0 
                             alt132=1;
 23301   
                             }
 23302   
                             break;
 23303   
                     }
 23304   
 
 23305  14 
                     switch (alt132) {
 23306   
                         case 1 :
 23307   
                             // com\\googlecode\\sparkleg\\Sparql.g:620:22: DISTINCT
 23308   
                             {
 23309  0 
                             DISTINCT639=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6483);
 23310  0 
                             stream_DISTINCT.add(DISTINCT639);
 23311   
 
 23312   
 
 23313   
                             }
 23314   
                             break;
 23315   
 
 23316   
                     }
 23317   
 
 23318   
 
 23319  14 
                     pushFollow(FOLLOW_expression_in_aggregate6486);
 23320  14 
                     expression640=expression();
 23321   
 
 23322  14 
                     state._fsp--;
 23323   
 
 23324  14 
                     stream_expression.add(expression640.getTree());
 23325   
 
 23326  14 
                     CLOSE_BRACE641=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6488);
 23327  14 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE641);
 23328   
 
 23329   
 
 23330   
                     // AST REWRITE
 23331   
                     // elements: expression, MIN, DISTINCT
 23332   
                     // token labels:
 23333   
                     // rule labels: retval
 23334   
                     // token list labels:
 23335   
                     // rule list labels:
 23336   
                     // wildcard labels:
 23337  14 
                     retval.tree = root_0;
 23338  14 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23339   
 
 23340  14 
                     root_0 = (Object)adaptor.nil();
 23341   
                     // 620:55: -> ^( MIN ( DISTINCT )* expression )
 23342   
                     {
 23343   
                         // com\\googlecode\\sparkleg\\Sparql.g:620:58: ^( MIN ( DISTINCT )* expression )
 23344   
                         {
 23345  14 
                         Object root_1 = (Object)adaptor.nil();
 23346  14 
                         root_1 = (Object)adaptor.becomeRoot(
 23347   
                         stream_MIN.nextNode()
 23348   
                         , root_1);
 23349   
 
 23350   
                         // com\\googlecode\\sparkleg\\Sparql.g:620:64: ( DISTINCT )*
 23351  14 
                         while ( stream_DISTINCT.hasNext() ) {
 23352  0 
                             adaptor.addChild(root_1,
 23353   
                             stream_DISTINCT.nextNode()
 23354   
                             );
 23355   
 
 23356   
                         }
 23357  14 
                         stream_DISTINCT.reset();
 23358   
 
 23359  14 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23360   
 
 23361  14 
                         adaptor.addChild(root_0, root_1);
 23362   
                         }
 23363   
 
 23364   
                     }
 23365   
 
 23366   
 
 23367  14 
                     retval.tree = root_0;
 23368   
 
 23369   
                     }
 23370  14 
                     break;
 23371   
                 case 4 :
 23372   
                     // com\\googlecode\\sparkleg\\Sparql.g:621:7: MAX OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23373   
                     {
 23374  10 
                     MAX642=(Token)match(input,MAX,FOLLOW_MAX_in_aggregate6507);
 23375  10 
                     stream_MAX.add(MAX642);
 23376   
 
 23377   
 
 23378  10 
                     OPEN_BRACE643=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6509);
 23379  10 
                     stream_OPEN_BRACE.add(OPEN_BRACE643);
 23380   
 
 23381   
 
 23382   
                     // com\\googlecode\\sparkleg\\Sparql.g:621:22: ( DISTINCT )?
 23383  10 
                     int alt133=2;
 23384  10 
                     switch ( input.LA(1) ) {
 23385   
                         case DISTINCT:
 23386   
                             {
 23387  0 
                             alt133=1;
 23388   
                             }
 23389   
                             break;
 23390   
                     }
 23391   
 
 23392  10 
                     switch (alt133) {
 23393   
                         case 1 :
 23394   
                             // com\\googlecode\\sparkleg\\Sparql.g:621:22: DISTINCT
 23395   
                             {
 23396  0 
                             DISTINCT644=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6511);
 23397  0 
                             stream_DISTINCT.add(DISTINCT644);
 23398   
 
 23399   
 
 23400   
                             }
 23401   
                             break;
 23402   
 
 23403   
                     }
 23404   
 
 23405   
 
 23406  10 
                     pushFollow(FOLLOW_expression_in_aggregate6514);
 23407  10 
                     expression645=expression();
 23408   
 
 23409  10 
                     state._fsp--;
 23410   
 
 23411  10 
                     stream_expression.add(expression645.getTree());
 23412   
 
 23413  10 
                     CLOSE_BRACE646=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6516);
 23414  10 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE646);
 23415   
 
 23416   
 
 23417   
                     // AST REWRITE
 23418   
                     // elements: DISTINCT, MAX, expression
 23419   
                     // token labels:
 23420   
                     // rule labels: retval
 23421   
                     // token list labels:
 23422   
                     // rule list labels:
 23423   
                     // wildcard labels:
 23424  10 
                     retval.tree = root_0;
 23425  10 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23426   
 
 23427  10 
                     root_0 = (Object)adaptor.nil();
 23428   
                     // 621:55: -> ^( MAX ( DISTINCT )* expression )
 23429   
                     {
 23430   
                         // com\\googlecode\\sparkleg\\Sparql.g:621:58: ^( MAX ( DISTINCT )* expression )
 23431   
                         {
 23432  10 
                         Object root_1 = (Object)adaptor.nil();
 23433  10 
                         root_1 = (Object)adaptor.becomeRoot(
 23434   
                         stream_MAX.nextNode()
 23435   
                         , root_1);
 23436   
 
 23437   
                         // com\\googlecode\\sparkleg\\Sparql.g:621:64: ( DISTINCT )*
 23438  10 
                         while ( stream_DISTINCT.hasNext() ) {
 23439  0 
                             adaptor.addChild(root_1,
 23440   
                             stream_DISTINCT.nextNode()
 23441   
                             );
 23442   
 
 23443   
                         }
 23444  10 
                         stream_DISTINCT.reset();
 23445   
 
 23446  10 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23447   
 
 23448  10 
                         adaptor.addChild(root_0, root_1);
 23449   
                         }
 23450   
 
 23451   
                     }
 23452   
 
 23453   
 
 23454  10 
                     retval.tree = root_0;
 23455   
 
 23456   
                     }
 23457  10 
                     break;
 23458   
                 case 5 :
 23459   
                     // com\\googlecode\\sparkleg\\Sparql.g:622:7: AVG OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23460   
                     {
 23461  24 
                     AVG647=(Token)match(input,AVG,FOLLOW_AVG_in_aggregate6535);
 23462  24 
                     stream_AVG.add(AVG647);
 23463   
 
 23464   
 
 23465  24 
                     OPEN_BRACE648=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6537);
 23466  24 
                     stream_OPEN_BRACE.add(OPEN_BRACE648);
 23467   
 
 23468   
 
 23469   
                     // com\\googlecode\\sparkleg\\Sparql.g:622:22: ( DISTINCT )?
 23470  24 
                     int alt134=2;
 23471  24 
                     switch ( input.LA(1) ) {
 23472   
                         case DISTINCT:
 23473   
                             {
 23474  0 
                             alt134=1;
 23475   
                             }
 23476   
                             break;
 23477   
                     }
 23478   
 
 23479  24 
                     switch (alt134) {
 23480   
                         case 1 :
 23481   
                             // com\\googlecode\\sparkleg\\Sparql.g:622:22: DISTINCT
 23482   
                             {
 23483  0 
                             DISTINCT649=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6539);
 23484  0 
                             stream_DISTINCT.add(DISTINCT649);
 23485   
 
 23486   
 
 23487   
                             }
 23488   
                             break;
 23489   
 
 23490   
                     }
 23491   
 
 23492   
 
 23493  24 
                     pushFollow(FOLLOW_expression_in_aggregate6542);
 23494  24 
                     expression650=expression();
 23495   
 
 23496  24 
                     state._fsp--;
 23497   
 
 23498  24 
                     stream_expression.add(expression650.getTree());
 23499   
 
 23500  24 
                     CLOSE_BRACE651=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6544);
 23501  24 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE651);
 23502   
 
 23503   
 
 23504   
                     // AST REWRITE
 23505   
                     // elements: DISTINCT, expression, AVG
 23506   
                     // token labels:
 23507   
                     // rule labels: retval
 23508   
                     // token list labels:
 23509   
                     // rule list labels:
 23510   
                     // wildcard labels:
 23511  24 
                     retval.tree = root_0;
 23512  24 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23513   
 
 23514  24 
                     root_0 = (Object)adaptor.nil();
 23515   
                     // 622:55: -> ^( AVG ( DISTINCT )* expression )
 23516   
                     {
 23517   
                         // com\\googlecode\\sparkleg\\Sparql.g:622:58: ^( AVG ( DISTINCT )* expression )
 23518   
                         {
 23519  24 
                         Object root_1 = (Object)adaptor.nil();
 23520  24 
                         root_1 = (Object)adaptor.becomeRoot(
 23521   
                         stream_AVG.nextNode()
 23522   
                         , root_1);
 23523   
 
 23524   
                         // com\\googlecode\\sparkleg\\Sparql.g:622:64: ( DISTINCT )*
 23525  24 
                         while ( stream_DISTINCT.hasNext() ) {
 23526  0 
                             adaptor.addChild(root_1,
 23527   
                             stream_DISTINCT.nextNode()
 23528   
                             );
 23529   
 
 23530   
                         }
 23531  24 
                         stream_DISTINCT.reset();
 23532   
 
 23533  24 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23534   
 
 23535  24 
                         adaptor.addChild(root_0, root_1);
 23536   
                         }
 23537   
 
 23538   
                     }
 23539   
 
 23540   
 
 23541  24 
                     retval.tree = root_0;
 23542   
 
 23543   
                     }
 23544  24 
                     break;
 23545   
                 case 6 :
 23546   
                     // com\\googlecode\\sparkleg\\Sparql.g:623:7: SAMPLE OPEN_BRACE ( DISTINCT )? expression CLOSE_BRACE
 23547   
                     {
 23548  6 
                     SAMPLE652=(Token)match(input,SAMPLE,FOLLOW_SAMPLE_in_aggregate6563);
 23549  6 
                     stream_SAMPLE.add(SAMPLE652);
 23550   
 
 23551   
 
 23552  6 
                     OPEN_BRACE653=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6565);
 23553  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE653);
 23554   
 
 23555   
 
 23556   
                     // com\\googlecode\\sparkleg\\Sparql.g:623:25: ( DISTINCT )?
 23557  6 
                     int alt135=2;
 23558  6 
                     switch ( input.LA(1) ) {
 23559   
                         case DISTINCT:
 23560   
                             {
 23561  0 
                             alt135=1;
 23562   
                             }
 23563   
                             break;
 23564   
                     }
 23565   
 
 23566  6 
                     switch (alt135) {
 23567   
                         case 1 :
 23568   
                             // com\\googlecode\\sparkleg\\Sparql.g:623:25: DISTINCT
 23569   
                             {
 23570  0 
                             DISTINCT654=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6567);
 23571  0 
                             stream_DISTINCT.add(DISTINCT654);
 23572   
 
 23573   
 
 23574   
                             }
 23575   
                             break;
 23576   
 
 23577   
                     }
 23578   
 
 23579   
 
 23580  6 
                     pushFollow(FOLLOW_expression_in_aggregate6570);
 23581  6 
                     expression655=expression();
 23582   
 
 23583  6 
                     state._fsp--;
 23584   
 
 23585  6 
                     stream_expression.add(expression655.getTree());
 23586   
 
 23587  6 
                     CLOSE_BRACE656=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6572);
 23588  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE656);
 23589   
 
 23590   
 
 23591   
                     // AST REWRITE
 23592   
                     // elements: SAMPLE, DISTINCT, expression
 23593   
                     // token labels:
 23594   
                     // rule labels: retval
 23595   
                     // token list labels:
 23596   
                     // rule list labels:
 23597   
                     // wildcard labels:
 23598  6 
                     retval.tree = root_0;
 23599  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23600   
 
 23601  6 
                     root_0 = (Object)adaptor.nil();
 23602   
                     // 623:58: -> ^( SAMPLE ( DISTINCT )? expression )
 23603   
                     {
 23604   
                         // com\\googlecode\\sparkleg\\Sparql.g:623:61: ^( SAMPLE ( DISTINCT )? expression )
 23605   
                         {
 23606  6 
                         Object root_1 = (Object)adaptor.nil();
 23607  6 
                         root_1 = (Object)adaptor.becomeRoot(
 23608   
                         stream_SAMPLE.nextNode()
 23609   
                         , root_1);
 23610   
 
 23611   
                         // com\\googlecode\\sparkleg\\Sparql.g:623:70: ( DISTINCT )?
 23612  6 
                         if ( stream_DISTINCT.hasNext() ) {
 23613  0 
                             adaptor.addChild(root_1,
 23614   
                             stream_DISTINCT.nextNode()
 23615   
                             );
 23616   
 
 23617   
                         }
 23618  6 
                         stream_DISTINCT.reset();
 23619   
 
 23620  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23621   
 
 23622  6 
                         adaptor.addChild(root_0, root_1);
 23623   
                         }
 23624   
 
 23625   
                     }
 23626   
 
 23627   
 
 23628  6 
                     retval.tree = root_0;
 23629   
 
 23630   
                     }
 23631  6 
                     break;
 23632   
                 case 7 :
 23633   
                     // com\\googlecode\\sparkleg\\Sparql.g:624:7: GROUP_CONCAT OPEN_BRACE ( DISTINCT )? expression ( SEMICOLON SEPARATOR EQUAL string )? CLOSE_BRACE
 23634   
                     {
 23635  6 
                     GROUP_CONCAT657=(Token)match(input,GROUP_CONCAT,FOLLOW_GROUP_CONCAT_in_aggregate6591);
 23636  6 
                     stream_GROUP_CONCAT.add(GROUP_CONCAT657);
 23637   
 
 23638   
 
 23639  6 
                     OPEN_BRACE658=(Token)match(input,OPEN_BRACE,FOLLOW_OPEN_BRACE_in_aggregate6593);
 23640  6 
                     stream_OPEN_BRACE.add(OPEN_BRACE658);
 23641   
 
 23642   
 
 23643   
                     // com\\googlecode\\sparkleg\\Sparql.g:624:31: ( DISTINCT )?
 23644  6 
                     int alt136=2;
 23645  6 
                     switch ( input.LA(1) ) {
 23646   
                         case DISTINCT:
 23647   
                             {
 23648  0 
                             alt136=1;
 23649   
                             }
 23650   
                             break;
 23651   
                     }
 23652   
 
 23653  6 
                     switch (alt136) {
 23654   
                         case 1 :
 23655   
                             // com\\googlecode\\sparkleg\\Sparql.g:624:31: DISTINCT
 23656   
                             {
 23657  0 
                             DISTINCT659=(Token)match(input,DISTINCT,FOLLOW_DISTINCT_in_aggregate6595);
 23658  0 
                             stream_DISTINCT.add(DISTINCT659);
 23659   
 
 23660   
 
 23661   
                             }
 23662   
                             break;
 23663   
 
 23664   
                     }
 23665   
 
 23666   
 
 23667  6 
                     pushFollow(FOLLOW_expression_in_aggregate6598);
 23668  6 
                     expression660=expression();
 23669   
 
 23670  6 
                     state._fsp--;
 23671   
 
 23672  6 
                     stream_expression.add(expression660.getTree());
 23673   
 
 23674   
                     // com\\googlecode\\sparkleg\\Sparql.g:624:52: ( SEMICOLON SEPARATOR EQUAL string )?
 23675  6 
                     int alt137=2;
 23676  6 
                     switch ( input.LA(1) ) {
 23677   
                         case SEMICOLON:
 23678   
                             {
 23679  2 
                             alt137=1;
 23680   
                             }
 23681   
                             break;
 23682   
                     }
 23683   
 
 23684  6 
                     switch (alt137) {
 23685   
                         case 1 :
 23686   
                             // com\\googlecode\\sparkleg\\Sparql.g:624:53: SEMICOLON SEPARATOR EQUAL string
 23687   
                             {
 23688  2 
                             SEMICOLON661=(Token)match(input,SEMICOLON,FOLLOW_SEMICOLON_in_aggregate6601);
 23689  2 
                             stream_SEMICOLON.add(SEMICOLON661);
 23690   
 
 23691   
 
 23692  2 
                             SEPARATOR662=(Token)match(input,SEPARATOR,FOLLOW_SEPARATOR_in_aggregate6603);
 23693  2 
                             stream_SEPARATOR.add(SEPARATOR662);
 23694   
 
 23695   
 
 23696  2 
                             EQUAL663=(Token)match(input,EQUAL,FOLLOW_EQUAL_in_aggregate6605);
 23697  2 
                             stream_EQUAL.add(EQUAL663);
 23698   
 
 23699   
 
 23700  2 
                             pushFollow(FOLLOW_string_in_aggregate6607);
 23701  2 
                             string664=string();
 23702   
 
 23703  2 
                             state._fsp--;
 23704   
 
 23705  2 
                             stream_string.add(string664.getTree());
 23706   
 
 23707   
                             }
 23708   
                             break;
 23709   
 
 23710   
                     }
 23711   
 
 23712   
 
 23713  6 
                     CLOSE_BRACE665=(Token)match(input,CLOSE_BRACE,FOLLOW_CLOSE_BRACE_in_aggregate6611);
 23714  6 
                     stream_CLOSE_BRACE.add(CLOSE_BRACE665);
 23715   
 
 23716   
 
 23717   
                     // AST REWRITE
 23718   
                     // elements: expression, GROUP_CONCAT, DISTINCT, string
 23719   
                     // token labels:
 23720   
                     // rule labels: retval
 23721   
                     // token list labels:
 23722   
                     // rule list labels:
 23723   
                     // wildcard labels:
 23724  6 
                     retval.tree = root_0;
 23725  6 
                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23726   
 
 23727  6 
                     root_0 = (Object)adaptor.nil();
 23728   
                     // 624:100: -> ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23729   
                     {
 23730   
                         // com\\googlecode\\sparkleg\\Sparql.g:624:103: ^( GROUP_CONCAT ( DISTINCT )* expression ( string )* )
 23731   
                         {
 23732  6 
                         Object root_1 = (Object)adaptor.nil();
 23733  6 
                         root_1 = (Object)adaptor.becomeRoot(
 23734   
                         stream_GROUP_CONCAT.nextNode()
 23735   
                         , root_1);
 23736   
 
 23737   
                         // com\\googlecode\\sparkleg\\Sparql.g:624:118: ( DISTINCT )*
 23738  6 
                         while ( stream_DISTINCT.hasNext() ) {
 23739  0 
                             adaptor.addChild(root_1,
 23740   
                             stream_DISTINCT.nextNode()
 23741   
                             );
 23742   
 
 23743   
                         }
 23744  6 
                         stream_DISTINCT.reset();
 23745   
 
 23746  6 
                         adaptor.addChild(root_1, stream_expression.nextTree());
 23747   
 
 23748   
                         // com\\googlecode\\sparkleg\\Sparql.g:624:139: ( string )*
 23749  8 
                         while ( stream_string.hasNext() ) {
 23750  2 
                             adaptor.addChild(root_1, stream_string.nextTree());
 23751   
 
 23752   
                         }
 23753  6 
                         stream_string.reset();
 23754   
 
 23755  6 
                         adaptor.addChild(root_0, root_1);
 23756   
                         }
 23757   
 
 23758   
                     }
 23759   
 
 23760   
 
 23761  6 
                     retval.tree = root_0;
 23762   
 
 23763   
                     }
 23764   
                     break;
 23765   
 
 23766   
             }
 23767  106 
             retval.stop = input.LT(-1);
 23768   
 
 23769   
 
 23770  106 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23771  106 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23772   
 
 23773   
         }
 23774  0 
         catch (RecognitionException re) {
 23775  0 
             reportError(re);
 23776  0 
             recover(input,re);
 23777  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23778   
 
 23779   
         }
 23780   
 
 23781  0 
         finally {
 23782   
                 // do for sure before leaving
 23783  106 
         }
 23784  106 
         return retval;
 23785   
     }
 23786   
     // $ANTLR end "aggregate"
 23787   
 
 23788   
 
 23789  178 
     public static class iriRefOrFunction_return extends ParserRuleReturnScope {
 23790   
         Object tree;
 23791  178 
         public Object getTree() { return tree; }
 23792   
     };
 23793   
 
 23794   
 
 23795   
     // $ANTLR start "iriRefOrFunction"
 23796   
     // com\\googlecode\\sparkleg\\Sparql.g:627:1: iriRefOrFunction : iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) ;
 23797   
     public final SparqlParser.iriRefOrFunction_return iriRefOrFunction() throws RecognitionException {
 23798  178 
         SparqlParser.iriRefOrFunction_return retval = new SparqlParser.iriRefOrFunction_return();
 23799  178 
         retval.start = input.LT(1);
 23800   
 
 23801   
 
 23802  178 
         Object root_0 = null;
 23803   
 
 23804  178 
         SparqlParser.iriRef_return iriRef666 =null;
 23805   
 
 23806  178 
         SparqlParser.argList_return argList667 =null;
 23807   
 
 23808   
 
 23809  178 
         RewriteRuleSubtreeStream stream_argList=new RewriteRuleSubtreeStream(adaptor,"rule argList");
 23810  178 
         RewriteRuleSubtreeStream stream_iriRef=new RewriteRuleSubtreeStream(adaptor,"rule iriRef");
 23811   
         try {
 23812   
             // com\\googlecode\\sparkleg\\Sparql.g:628:5: ( iriRef ( argList )? -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? ) )
 23813   
             // com\\googlecode\\sparkleg\\Sparql.g:628:7: iriRef ( argList )?
 23814   
             {
 23815  178 
             pushFollow(FOLLOW_iriRef_in_iriRefOrFunction6646);
 23816  178 
             iriRef666=iriRef();
 23817   
 
 23818  178 
             state._fsp--;
 23819   
 
 23820  178 
             stream_iriRef.add(iriRef666.getTree());
 23821   
 
 23822   
             // com\\googlecode\\sparkleg\\Sparql.g:628:14: ( argList )?
 23823  178 
             int alt139=2;
 23824  178 
             switch ( input.LA(1) ) {
 23825   
                 case OPEN_BRACE:
 23826   
                     {
 23827  113 
                     alt139=1;
 23828   
                     }
 23829   
                     break;
 23830   
             }
 23831   
 
 23832  178 
             switch (alt139) {
 23833   
                 case 1 :
 23834   
                     // com\\googlecode\\sparkleg\\Sparql.g:628:14: argList
 23835   
                     {
 23836  113 
                     pushFollow(FOLLOW_argList_in_iriRefOrFunction6648);
 23837  113 
                     argList667=argList();
 23838   
 
 23839  113 
                     state._fsp--;
 23840   
 
 23841  113 
                     stream_argList.add(argList667.getTree());
 23842   
 
 23843   
                     }
 23844   
                     break;
 23845   
 
 23846   
             }
 23847   
 
 23848   
 
 23849   
             // AST REWRITE
 23850   
             // elements: iriRef, argList
 23851   
             // token labels:
 23852   
             // rule labels: retval
 23853   
             // token list labels:
 23854   
             // rule list labels:
 23855   
             // wildcard labels:
 23856  178 
             retval.tree = root_0;
 23857  178 
             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
 23858   
 
 23859  178 
             root_0 = (Object)adaptor.nil();
 23860   
             // 628:23: -> ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23861   
             {
 23862   
                 // com\\googlecode\\sparkleg\\Sparql.g:628:26: ^( FUNCTION iriRef ( ^( ARG_LIST argList ) )? )
 23863   
                 {
 23864  178 
                 Object root_1 = (Object)adaptor.nil();
 23865  178 
                 root_1 = (Object)adaptor.becomeRoot(
 23866   
                 (Object)adaptor.create(FUNCTION, "FUNCTION")
 23867   
                 , root_1);
 23868   
 
 23869  178 
                 adaptor.addChild(root_1, stream_iriRef.nextTree());
 23870   
 
 23871   
                 // com\\googlecode\\sparkleg\\Sparql.g:628:44: ( ^( ARG_LIST argList ) )?
 23872  178 
                 if ( stream_argList.hasNext() ) {
 23873   
                     // com\\googlecode\\sparkleg\\Sparql.g:628:44: ^( ARG_LIST argList )
 23874   
                     {
 23875  113 
                     Object root_2 = (Object)adaptor.nil();
 23876  113 
                     root_2 = (Object)adaptor.becomeRoot(
 23877   
                     (Object)adaptor.create(ARG_LIST, "ARG_LIST")
 23878   
                     , root_2);
 23879   
 
 23880  113 
                     adaptor.addChild(root_2, stream_argList.nextTree());
 23881   
 
 23882  113 
                     adaptor.addChild(root_1, root_2);
 23883   
                     }
 23884   
 
 23885   
                 }
 23886  178 
                 stream_argList.reset();
 23887   
 
 23888  178 
                 adaptor.addChild(root_0, root_1);
 23889   
                 }
 23890   
 
 23891   
             }
 23892   
 
 23893   
 
 23894  178 
             retval.tree = root_0;
 23895   
 
 23896   
             }
 23897   
 
 23898  178 
             retval.stop = input.LT(-1);
 23899   
 
 23900   
 
 23901  178 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 23902  178 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 23903   
 
 23904   
         }
 23905  0 
         catch (RecognitionException re) {
 23906  0 
             reportError(re);
 23907  0 
             recover(input,re);
 23908  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 23909   
 
 23910   
         }
 23911   
 
 23912  0 
         finally {
 23913   
                 // do for sure before leaving
 23914  178 
         }
 23915  178 
         return retval;
 23916   
     }
 23917   
     // $ANTLR end "iriRefOrFunction"
 23918   
 
 23919   
 
 23920  378 
     public static class rdfLiteral_return extends ParserRuleReturnScope {
 23921   
         Object tree;
 23922  378 
         public Object getTree() { return tree; }
 23923   
     };
 23924   
 
 23925   
 
 23926   
     // $ANTLR start "rdfLiteral"
 23927   
     // com\\googlecode\\sparkleg\\Sparql.g:631:1: rdfLiteral : string ( LANGTAG | ( REFERENCE iriRef ) )? ;
 23928   
     public final SparqlParser.rdfLiteral_return rdfLiteral() throws RecognitionException {
 23929  378 
         SparqlParser.rdfLiteral_return retval = new SparqlParser.rdfLiteral_return();
 23930  378 
         retval.start = input.LT(1);
 23931   
 
 23932   
 
 23933  378 
         Object root_0 = null;
 23934   
 
 23935  378 
         Token LANGTAG669=null;
 23936  378 
         Token REFERENCE670=null;
 23937  378 
         SparqlParser.string_return string668 =null;
 23938   
 
 23939  378 
         SparqlParser.iriRef_return iriRef671 =null;
 23940   
 
 23941   
 
 23942  378 
         Object LANGTAG669_tree=null;
 23943  378 
         Object REFERENCE670_tree=null;
 23944   
 
 23945   
         try {
 23946   
             // com\\googlecode\\sparkleg\\Sparql.g:632:5: ( string ( LANGTAG | ( REFERENCE iriRef ) )? )
 23947   
             // com\\googlecode\\sparkleg\\Sparql.g:632:7: string ( LANGTAG | ( REFERENCE iriRef ) )?
 23948   
             {
 23949  378 
             root_0 = (Object)adaptor.nil();
 23950   
 
 23951   
 
 23952  378 
             pushFollow(FOLLOW_string_in_rdfLiteral6681);
 23953  378 
             string668=string();
 23954   
 
 23955  378 
             state._fsp--;
 23956   
 
 23957  378 
             adaptor.addChild(root_0, string668.getTree());
 23958   
 
 23959   
             // com\\googlecode\\sparkleg\\Sparql.g:632:14: ( LANGTAG | ( REFERENCE iriRef ) )?
 23960  378 
             int alt140=3;
 23961  378 
             switch ( input.LA(1) ) {
 23962   
                 case LANGTAG:
 23963   
                     {
 23964  10 
                     alt140=1;
 23965   
                     }
 23966  10 
                     break;
 23967   
                 case REFERENCE:
 23968   
                     {
 23969  38 
                     alt140=2;
 23970   
                     }
 23971   
                     break;
 23972   
             }
 23973   
 
 23974  378 
             switch (alt140) {
 23975   
                 case 1 :
 23976   
                     // com\\googlecode\\sparkleg\\Sparql.g:632:15: LANGTAG
 23977   
                     {
 23978  10 
                     LANGTAG669=(Token)match(input,LANGTAG,FOLLOW_LANGTAG_in_rdfLiteral6684);
 23979  10 
                     LANGTAG669_tree =
 23980   
                     (Object)adaptor.create(LANGTAG669)
 23981   
                     ;
 23982  10 
                     adaptor.addChild(root_0, LANGTAG669_tree);
 23983   
 
 23984   
 
 23985   
                     }
 23986  10 
                     break;
 23987   
                 case 2 :
 23988   
                     // com\\googlecode\\sparkleg\\Sparql.g:632:25: ( REFERENCE iriRef )
 23989   
                     {
 23990   
                     // com\\googlecode\\sparkleg\\Sparql.g:632:25: ( REFERENCE iriRef )
 23991   
                     // com\\googlecode\\sparkleg\\Sparql.g:632:26: REFERENCE iriRef
 23992   
                     {
 23993  38 
                     REFERENCE670=(Token)match(input,REFERENCE,FOLLOW_REFERENCE_in_rdfLiteral6689);
 23994  38 
                     REFERENCE670_tree =
 23995   
                     (Object)adaptor.create(REFERENCE670)
 23996   
                     ;
 23997  38 
                     adaptor.addChild(root_0, REFERENCE670_tree);
 23998   
 
 23999   
 
 24000  38 
                     pushFollow(FOLLOW_iriRef_in_rdfLiteral6691);
 24001  38 
                     iriRef671=iriRef();
 24002   
 
 24003  38 
                     state._fsp--;
 24004   
 
 24005  38 
                     adaptor.addChild(root_0, iriRef671.getTree());
 24006   
 
 24007   
                     }
 24008   
 
 24009   
 
 24010   
                     }
 24011   
                     break;
 24012   
 
 24013   
             }
 24014   
 
 24015   
 
 24016   
             }
 24017   
 
 24018  378 
             retval.stop = input.LT(-1);
 24019   
 
 24020   
 
 24021  378 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24022  378 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24023   
 
 24024   
         }
 24025  0 
         catch (RecognitionException re) {
 24026  0 
             reportError(re);
 24027  0 
             recover(input,re);
 24028  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24029   
 
 24030   
         }
 24031   
 
 24032  0 
         finally {
 24033   
                 // do for sure before leaving
 24034  378 
         }
 24035  378 
         return retval;
 24036   
     }
 24037   
     // $ANTLR end "rdfLiteral"
 24038   
 
 24039   
 
 24040  300 
     public static class numericLiteral_return extends ParserRuleReturnScope {
 24041   
         Object tree;
 24042  300 
         public Object getTree() { return tree; }
 24043   
     };
 24044   
 
 24045   
 
 24046   
     // $ANTLR start "numericLiteral"
 24047   
     // com\\googlecode\\sparkleg\\Sparql.g:635:1: numericLiteral : ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative );
 24048   
     public final SparqlParser.numericLiteral_return numericLiteral() throws RecognitionException {
 24049  300 
         SparqlParser.numericLiteral_return retval = new SparqlParser.numericLiteral_return();
 24050  300 
         retval.start = input.LT(1);
 24051   
 
 24052   
 
 24053  300 
         Object root_0 = null;
 24054   
 
 24055  300 
         SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned672 =null;
 24056   
 
 24057  300 
         SparqlParser.numericLiteralPositive_return numericLiteralPositive673 =null;
 24058   
 
 24059  300 
         SparqlParser.numericLiteralNegative_return numericLiteralNegative674 =null;
 24060   
 
 24061   
 
 24062   
 
 24063   
         try {
 24064   
             // com\\googlecode\\sparkleg\\Sparql.g:636:5: ( numericLiteralUnsigned | numericLiteralPositive | numericLiteralNegative )
 24065  300 
             int alt141=3;
 24066  300 
             switch ( input.LA(1) ) {
 24067   
             case DECIMAL:
 24068   
             case DOUBLE:
 24069   
             case INTEGER:
 24070   
                 {
 24071  254 
                 alt141=1;
 24072   
                 }
 24073  254 
                 break;
 24074   
             case DECIMAL_POSITIVE:
 24075   
             case DOUBLE_POSITIVE:
 24076   
             case INTEGER_POSITIVE:
 24077   
                 {
 24078  30 
                 alt141=2;
 24079   
                 }
 24080  30 
                 break;
 24081   
             case DECIMAL_NEGATIVE:
 24082   
             case DOUBLE_NEGATIVE:
 24083   
             case INTEGER_NEGATIVE:
 24084   
                 {
 24085  16 
                 alt141=3;
 24086   
                 }
 24087  16 
                 break;
 24088   
             default:
 24089  0 
                 NoViableAltException nvae =
 24090   
                     new NoViableAltException("", 141, 0, input);
 24091   
 
 24092  0 
                 throw nvae;
 24093   
 
 24094   
             }
 24095   
 
 24096  300 
             switch (alt141) {
 24097   
                 case 1 :
 24098   
                     // com\\googlecode\\sparkleg\\Sparql.g:636:7: numericLiteralUnsigned
 24099   
                     {
 24100  254 
                     root_0 = (Object)adaptor.nil();
 24101   
 
 24102   
 
 24103  254 
                     pushFollow(FOLLOW_numericLiteralUnsigned_in_numericLiteral6711);
 24104  254 
                     numericLiteralUnsigned672=numericLiteralUnsigned();
 24105   
 
 24106  254 
                     state._fsp--;
 24107   
 
 24108  254 
                     adaptor.addChild(root_0, numericLiteralUnsigned672.getTree());
 24109   
 
 24110   
                     }
 24111  254 
                     break;
 24112   
                 case 2 :
 24113   
                     // com\\googlecode\\sparkleg\\Sparql.g:637:7: numericLiteralPositive
 24114   
                     {
 24115  30 
                     root_0 = (Object)adaptor.nil();
 24116   
 
 24117   
 
 24118  30 
                     pushFollow(FOLLOW_numericLiteralPositive_in_numericLiteral6719);
 24119  30 
                     numericLiteralPositive673=numericLiteralPositive();
 24120   
 
 24121  30 
                     state._fsp--;
 24122   
 
 24123  30 
                     adaptor.addChild(root_0, numericLiteralPositive673.getTree());
 24124   
 
 24125   
                     }
 24126  30 
                     break;
 24127   
                 case 3 :
 24128   
                     // com\\googlecode\\sparkleg\\Sparql.g:638:7: numericLiteralNegative
 24129   
                     {
 24130  16 
                     root_0 = (Object)adaptor.nil();
 24131   
 
 24132   
 
 24133  16 
                     pushFollow(FOLLOW_numericLiteralNegative_in_numericLiteral6727);
 24134  16 
                     numericLiteralNegative674=numericLiteralNegative();
 24135   
 
 24136  16 
                     state._fsp--;
 24137   
 
 24138  16 
                     adaptor.addChild(root_0, numericLiteralNegative674.getTree());
 24139   
 
 24140   
                     }
 24141   
                     break;
 24142   
 
 24143   
             }
 24144  300 
             retval.stop = input.LT(-1);
 24145   
 
 24146   
 
 24147  300 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24148  300 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24149   
 
 24150   
         }
 24151  0 
         catch (RecognitionException re) {
 24152  0 
             reportError(re);
 24153  0 
             recover(input,re);
 24154  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24155   
 
 24156   
         }
 24157   
 
 24158  0 
         finally {
 24159   
                 // do for sure before leaving
 24160  300 
         }
 24161  300 
         return retval;
 24162   
     }
 24163   
     // $ANTLR end "numericLiteral"
 24164   
 
 24165   
 
 24166  254 
     public static class numericLiteralUnsigned_return extends ParserRuleReturnScope {
 24167   
         Object tree;
 24168  254 
         public Object getTree() { return tree; }
 24169   
     };
 24170   
 
 24171   
 
 24172   
     // $ANTLR start "numericLiteralUnsigned"
 24173   
     // com\\googlecode\\sparkleg\\Sparql.g:641:1: numericLiteralUnsigned : ( INTEGER | DECIMAL | DOUBLE );
 24174   
     public final SparqlParser.numericLiteralUnsigned_return numericLiteralUnsigned() throws RecognitionException {
 24175  254 
         SparqlParser.numericLiteralUnsigned_return retval = new SparqlParser.numericLiteralUnsigned_return();
 24176  254 
         retval.start = input.LT(1);
 24177   
 
 24178   
 
 24179  254 
         Object root_0 = null;
 24180   
 
 24181  254 
         Token set675=null;
 24182   
 
 24183  254 
         Object set675_tree=null;
 24184   
 
 24185   
         try {
 24186   
             // com\\googlecode\\sparkleg\\Sparql.g:642:5: ( INTEGER | DECIMAL | DOUBLE )
 24187   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24188   
             {
 24189  254 
             root_0 = (Object)adaptor.nil();
 24190   
 
 24191   
 
 24192  254 
             set675=(Token)input.LT(1);
 24193   
 
 24194  254 
             if ( input.LA(1)==DECIMAL||input.LA(1)==DOUBLE||input.LA(1)==INTEGER ) {
 24195  254 
                 input.consume();
 24196  254 
                 adaptor.addChild(root_0,
 24197   
                 (Object)adaptor.create(set675)
 24198   
                 );
 24199  254 
                 state.errorRecovery=false;
 24200   
             }
 24201   
             else {
 24202  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24203  0 
                 throw mse;
 24204   
             }
 24205   
 
 24206   
 
 24207   
             }
 24208   
 
 24209  254 
             retval.stop = input.LT(-1);
 24210   
 
 24211   
 
 24212  254 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24213  254 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24214   
 
 24215   
         }
 24216  0 
         catch (RecognitionException re) {
 24217  0 
             reportError(re);
 24218  0 
             recover(input,re);
 24219  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24220   
 
 24221   
         }
 24222   
 
 24223  0 
         finally {
 24224   
                 // do for sure before leaving
 24225  254 
         }
 24226  254 
         return retval;
 24227   
     }
 24228   
     // $ANTLR end "numericLiteralUnsigned"
 24229   
 
 24230   
 
 24231  50 
     public static class numericLiteralPositive_return extends ParserRuleReturnScope {
 24232   
         Object tree;
 24233  50 
         public Object getTree() { return tree; }
 24234   
     };
 24235   
 
 24236   
 
 24237   
     // $ANTLR start "numericLiteralPositive"
 24238   
     // com\\googlecode\\sparkleg\\Sparql.g:647:1: numericLiteralPositive : ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE );
 24239   
     public final SparqlParser.numericLiteralPositive_return numericLiteralPositive() throws RecognitionException {
 24240  50 
         SparqlParser.numericLiteralPositive_return retval = new SparqlParser.numericLiteralPositive_return();
 24241  50 
         retval.start = input.LT(1);
 24242   
 
 24243   
 
 24244  50 
         Object root_0 = null;
 24245   
 
 24246  50 
         Token set676=null;
 24247   
 
 24248  50 
         Object set676_tree=null;
 24249   
 
 24250   
         try {
 24251   
             // com\\googlecode\\sparkleg\\Sparql.g:648:5: ( INTEGER_POSITIVE | DECIMAL_POSITIVE | DOUBLE_POSITIVE )
 24252   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24253   
             {
 24254  50 
             root_0 = (Object)adaptor.nil();
 24255   
 
 24256   
 
 24257  50 
             set676=(Token)input.LT(1);
 24258   
 
 24259  50 
             if ( input.LA(1)==DECIMAL_POSITIVE||input.LA(1)==DOUBLE_POSITIVE||input.LA(1)==INTEGER_POSITIVE ) {
 24260  50 
                 input.consume();
 24261  50 
                 adaptor.addChild(root_0,
 24262   
                 (Object)adaptor.create(set676)
 24263   
                 );
 24264  50 
                 state.errorRecovery=false;
 24265   
             }
 24266   
             else {
 24267  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24268  0 
                 throw mse;
 24269   
             }
 24270   
 
 24271   
 
 24272   
             }
 24273   
 
 24274  50 
             retval.stop = input.LT(-1);
 24275   
 
 24276   
 
 24277  50 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24278  50 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24279   
 
 24280   
         }
 24281  0 
         catch (RecognitionException re) {
 24282  0 
             reportError(re);
 24283  0 
             recover(input,re);
 24284  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24285   
 
 24286   
         }
 24287   
 
 24288  0 
         finally {
 24289   
                 // do for sure before leaving
 24290  50 
         }
 24291  50 
         return retval;
 24292   
     }
 24293   
     // $ANTLR end "numericLiteralPositive"
 24294   
 
 24295   
 
 24296  16 
     public static class numericLiteralNegative_return extends ParserRuleReturnScope {
 24297   
         Object tree;
 24298  16 
         public Object getTree() { return tree; }
 24299   
     };
 24300   
 
 24301   
 
 24302   
     // $ANTLR start "numericLiteralNegative"
 24303   
     // com\\googlecode\\sparkleg\\Sparql.g:653:1: numericLiteralNegative : ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE );
 24304   
     public final SparqlParser.numericLiteralNegative_return numericLiteralNegative() throws RecognitionException {
 24305  16 
         SparqlParser.numericLiteralNegative_return retval = new SparqlParser.numericLiteralNegative_return();
 24306  16 
         retval.start = input.LT(1);
 24307   
 
 24308   
 
 24309  16 
         Object root_0 = null;
 24310   
 
 24311  16 
         Token set677=null;
 24312   
 
 24313  16 
         Object set677_tree=null;
 24314   
 
 24315   
         try {
 24316   
             // com\\googlecode\\sparkleg\\Sparql.g:654:5: ( INTEGER_NEGATIVE | DECIMAL_NEGATIVE | DOUBLE_NEGATIVE )
 24317   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24318   
             {
 24319  16 
             root_0 = (Object)adaptor.nil();
 24320   
 
 24321   
 
 24322  16 
             set677=(Token)input.LT(1);
 24323   
 
 24324  16 
             if ( input.LA(1)==DECIMAL_NEGATIVE||input.LA(1)==DOUBLE_NEGATIVE||input.LA(1)==INTEGER_NEGATIVE ) {
 24325  16 
                 input.consume();
 24326  16 
                 adaptor.addChild(root_0,
 24327   
                 (Object)adaptor.create(set677)
 24328   
                 );
 24329  16 
                 state.errorRecovery=false;
 24330   
             }
 24331   
             else {
 24332  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24333  0 
                 throw mse;
 24334   
             }
 24335   
 
 24336   
 
 24337   
             }
 24338   
 
 24339  16 
             retval.stop = input.LT(-1);
 24340   
 
 24341   
 
 24342  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24343  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24344   
 
 24345   
         }
 24346  0 
         catch (RecognitionException re) {
 24347  0 
             reportError(re);
 24348  0 
             recover(input,re);
 24349  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24350   
 
 24351   
         }
 24352   
 
 24353  0 
         finally {
 24354   
                 // do for sure before leaving
 24355  16 
         }
 24356  16 
         return retval;
 24357   
     }
 24358   
     // $ANTLR end "numericLiteralNegative"
 24359   
 
 24360   
 
 24361  16 
     public static class booleanLiteral_return extends ParserRuleReturnScope {
 24362   
         Object tree;
 24363  16 
         public Object getTree() { return tree; }
 24364   
     };
 24365   
 
 24366   
 
 24367   
     // $ANTLR start "booleanLiteral"
 24368   
     // com\\googlecode\\sparkleg\\Sparql.g:659:1: booleanLiteral : ( TRUE | FALSE );
 24369   
     public final SparqlParser.booleanLiteral_return booleanLiteral() throws RecognitionException {
 24370  16 
         SparqlParser.booleanLiteral_return retval = new SparqlParser.booleanLiteral_return();
 24371  16 
         retval.start = input.LT(1);
 24372   
 
 24373   
 
 24374  16 
         Object root_0 = null;
 24375   
 
 24376  16 
         Token set678=null;
 24377   
 
 24378  16 
         Object set678_tree=null;
 24379   
 
 24380   
         try {
 24381   
             // com\\googlecode\\sparkleg\\Sparql.g:660:5: ( TRUE | FALSE )
 24382   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24383   
             {
 24384  16 
             root_0 = (Object)adaptor.nil();
 24385   
 
 24386   
 
 24387  16 
             set678=(Token)input.LT(1);
 24388   
 
 24389  16 
             if ( input.LA(1)==FALSE||input.LA(1)==TRUE ) {
 24390  16 
                 input.consume();
 24391  16 
                 adaptor.addChild(root_0,
 24392   
                 (Object)adaptor.create(set678)
 24393   
                 );
 24394  16 
                 state.errorRecovery=false;
 24395   
             }
 24396   
             else {
 24397  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24398  0 
                 throw mse;
 24399   
             }
 24400   
 
 24401   
 
 24402   
             }
 24403   
 
 24404  16 
             retval.stop = input.LT(-1);
 24405   
 
 24406   
 
 24407  16 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24408  16 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24409   
 
 24410   
         }
 24411  0 
         catch (RecognitionException re) {
 24412  0 
             reportError(re);
 24413  0 
             recover(input,re);
 24414  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24415   
 
 24416   
         }
 24417   
 
 24418  0 
         finally {
 24419   
                 // do for sure before leaving
 24420  16 
         }
 24421  16 
         return retval;
 24422   
     }
 24423   
     // $ANTLR end "booleanLiteral"
 24424   
 
 24425   
 
 24426  380 
     public static class string_return extends ParserRuleReturnScope {
 24427   
         Object tree;
 24428  380 
         public Object getTree() { return tree; }
 24429   
     };
 24430   
 
 24431   
 
 24432   
     // $ANTLR start "string"
 24433   
     // com\\googlecode\\sparkleg\\Sparql.g:664:1: string : ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 );
 24434   
     public final SparqlParser.string_return string() throws RecognitionException {
 24435  380 
         SparqlParser.string_return retval = new SparqlParser.string_return();
 24436  380 
         retval.start = input.LT(1);
 24437   
 
 24438   
 
 24439  380 
         Object root_0 = null;
 24440   
 
 24441  380 
         Token set679=null;
 24442   
 
 24443  380 
         Object set679_tree=null;
 24444   
 
 24445   
         try {
 24446   
             // com\\googlecode\\sparkleg\\Sparql.g:665:5: ( STRING_LITERAL1 | STRING_LITERAL2 | STRING_LITERAL_LONG1 | STRING_LITERAL_LONG2 )
 24447   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24448   
             {
 24449  380 
             root_0 = (Object)adaptor.nil();
 24450   
 
 24451   
 
 24452  380 
             set679=(Token)input.LT(1);
 24453   
 
 24454  380 
             if ( (input.LA(1) >= STRING_LITERAL1 && input.LA(1) <= STRING_LITERAL_LONG2) ) {
 24455  380 
                 input.consume();
 24456  380 
                 adaptor.addChild(root_0,
 24457   
                 (Object)adaptor.create(set679)
 24458   
                 );
 24459  380 
                 state.errorRecovery=false;
 24460   
             }
 24461   
             else {
 24462  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24463  0 
                 throw mse;
 24464   
             }
 24465   
 
 24466   
 
 24467   
             }
 24468   
 
 24469  380 
             retval.stop = input.LT(-1);
 24470   
 
 24471   
 
 24472  380 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24473  380 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24474   
 
 24475   
         }
 24476  0 
         catch (RecognitionException re) {
 24477  0 
             reportError(re);
 24478  0 
             recover(input,re);
 24479  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24480   
 
 24481   
         }
 24482   
 
 24483  0 
         finally {
 24484   
                 // do for sure before leaving
 24485  380 
         }
 24486  380 
         return retval;
 24487   
     }
 24488   
     // $ANTLR end "string"
 24489   
 
 24490   
 
 24491  4301 
     public static class iriRef_return extends ParserRuleReturnScope {
 24492   
         Object tree;
 24493  4301 
         public Object getTree() { return tree; }
 24494   
     };
 24495   
 
 24496   
 
 24497   
     // $ANTLR start "iriRef"
 24498   
     // com\\googlecode\\sparkleg\\Sparql.g:671:1: iriRef : ( IRI_REF | prefixedName );
 24499   
     public final SparqlParser.iriRef_return iriRef() throws RecognitionException {
 24500  4301 
         SparqlParser.iriRef_return retval = new SparqlParser.iriRef_return();
 24501  4301 
         retval.start = input.LT(1);
 24502   
 
 24503   
 
 24504  4301 
         Object root_0 = null;
 24505   
 
 24506  4301 
         Token IRI_REF680=null;
 24507  4301 
         SparqlParser.prefixedName_return prefixedName681 =null;
 24508   
 
 24509   
 
 24510  4301 
         Object IRI_REF680_tree=null;
 24511   
 
 24512   
         try {
 24513   
             // com\\googlecode\\sparkleg\\Sparql.g:672:5: ( IRI_REF | prefixedName )
 24514  4301 
             int alt142=2;
 24515  4301 
             switch ( input.LA(1) ) {
 24516   
             case IRI_REF:
 24517   
                 {
 24518  466 
                 alt142=1;
 24519   
                 }
 24520  466 
                 break;
 24521   
             case PNAME_LN:
 24522   
             case PNAME_NS:
 24523   
                 {
 24524  3835 
                 alt142=2;
 24525   
                 }
 24526  3835 
                 break;
 24527   
             default:
 24528  0 
                 NoViableAltException nvae =
 24529   
                     new NoViableAltException("", 142, 0, input);
 24530   
 
 24531  0 
                 throw nvae;
 24532   
 
 24533   
             }
 24534   
 
 24535  4301 
             switch (alt142) {
 24536   
                 case 1 :
 24537   
                     // com\\googlecode\\sparkleg\\Sparql.g:672:7: IRI_REF
 24538   
                     {
 24539  466 
                     root_0 = (Object)adaptor.nil();
 24540   
 
 24541   
 
 24542  466 
                     IRI_REF680=(Token)match(input,IRI_REF,FOLLOW_IRI_REF_in_iriRef6910);
 24543  466 
                     IRI_REF680_tree =
 24544   
                     (Object)adaptor.create(IRI_REF680)
 24545   
                     ;
 24546  466 
                     adaptor.addChild(root_0, IRI_REF680_tree);
 24547   
 
 24548   
 
 24549   
                     }
 24550  466 
                     break;
 24551   
                 case 2 :
 24552   
                     // com\\googlecode\\sparkleg\\Sparql.g:673:7: prefixedName
 24553   
                     {
 24554  3835 
                     root_0 = (Object)adaptor.nil();
 24555   
 
 24556   
 
 24557  3835 
                     pushFollow(FOLLOW_prefixedName_in_iriRef6918);
 24558  3835 
                     prefixedName681=prefixedName();
 24559   
 
 24560  3835 
                     state._fsp--;
 24561   
 
 24562  3835 
                     adaptor.addChild(root_0, prefixedName681.getTree());
 24563   
 
 24564   
                     }
 24565   
                     break;
 24566   
 
 24567   
             }
 24568  4301 
             retval.stop = input.LT(-1);
 24569   
 
 24570   
 
 24571  4301 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24572  4301 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24573   
 
 24574   
         }
 24575  0 
         catch (RecognitionException re) {
 24576  0 
             reportError(re);
 24577  0 
             recover(input,re);
 24578  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24579   
 
 24580   
         }
 24581   
 
 24582  0 
         finally {
 24583   
                 // do for sure before leaving
 24584  4301 
         }
 24585  4301 
         return retval;
 24586   
     }
 24587   
     // $ANTLR end "iriRef"
 24588   
 
 24589   
 
 24590  3835 
     public static class prefixedName_return extends ParserRuleReturnScope {
 24591   
         Object tree;
 24592  3835 
         public Object getTree() { return tree; }
 24593   
     };
 24594   
 
 24595   
 
 24596   
     // $ANTLR start "prefixedName"
 24597   
     // com\\googlecode\\sparkleg\\Sparql.g:676:1: prefixedName : ( PNAME_LN | PNAME_NS );
 24598   
     public final SparqlParser.prefixedName_return prefixedName() throws RecognitionException {
 24599  3835 
         SparqlParser.prefixedName_return retval = new SparqlParser.prefixedName_return();
 24600  3835 
         retval.start = input.LT(1);
 24601   
 
 24602   
 
 24603  3835 
         Object root_0 = null;
 24604   
 
 24605  3835 
         Token set682=null;
 24606   
 
 24607  3835 
         Object set682_tree=null;
 24608   
 
 24609   
         try {
 24610   
             // com\\googlecode\\sparkleg\\Sparql.g:677:5: ( PNAME_LN | PNAME_NS )
 24611   
             // com\\googlecode\\sparkleg\\Sparql.g:
 24612   
             {
 24613  3835 
             root_0 = (Object)adaptor.nil();
 24614   
 
 24615   
 
 24616  3835 
             set682=(Token)input.LT(1);
 24617   
 
 24618  3835 
             if ( (input.LA(1) >= PNAME_LN && input.LA(1) <= PNAME_NS) ) {
 24619  3835 
                 input.consume();
 24620  3835 
                 adaptor.addChild(root_0,
 24621   
                 (Object)adaptor.create(set682)
 24622   
                 );
 24623  3835 
                 state.errorRecovery=false;
 24624   
             }
 24625   
             else {
 24626  0 
                 MismatchedSetException mse = new MismatchedSetException(null,input);
 24627  0 
                 throw mse;
 24628   
             }
 24629   
 
 24630   
 
 24631   
             }
 24632   
 
 24633  3835 
             retval.stop = input.LT(-1);
 24634   
 
 24635   
 
 24636  3835 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24637  3835 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24638   
 
 24639   
         }
 24640  0 
         catch (RecognitionException re) {
 24641  0 
             reportError(re);
 24642  0 
             recover(input,re);
 24643  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24644   
 
 24645   
         }
 24646   
 
 24647  0 
         finally {
 24648   
                 // do for sure before leaving
 24649  3835 
         }
 24650  3835 
         return retval;
 24651   
     }
 24652   
     // $ANTLR end "prefixedName"
 24653   
 
 24654   
 
 24655  192 
     public static class blankNode_return extends ParserRuleReturnScope {
 24656   
         Object tree;
 24657  192 
         public Object getTree() { return tree; }
 24658   
     };
 24659   
 
 24660   
 
 24661   
     // $ANTLR start "blankNode"
 24662   
     // com\\googlecode\\sparkleg\\Sparql.g:681:1: blankNode : ( BLANK_NODE_LABEL | anon );
 24663   
     public final SparqlParser.blankNode_return blankNode() throws RecognitionException {
 24664  192 
         SparqlParser.blankNode_return retval = new SparqlParser.blankNode_return();
 24665  192 
         retval.start = input.LT(1);
 24666   
 
 24667   
 
 24668  192 
         Object root_0 = null;
 24669   
 
 24670  192 
         Token BLANK_NODE_LABEL683=null;
 24671  192 
         SparqlParser.anon_return anon684 =null;
 24672   
 
 24673   
 
 24674  192 
         Object BLANK_NODE_LABEL683_tree=null;
 24675   
 
 24676   
         try {
 24677   
             // com\\googlecode\\sparkleg\\Sparql.g:682:5: ( BLANK_NODE_LABEL | anon )
 24678  192 
             int alt143=2;
 24679  192 
             switch ( input.LA(1) ) {
 24680   
             case BLANK_NODE_LABEL:
 24681   
                 {
 24682  108 
                 alt143=1;
 24683   
                 }
 24684  108 
                 break;
 24685   
             case OPEN_SQUARE_BRACKET:
 24686   
                 {
 24687  84 
                 alt143=2;
 24688   
                 }
 24689  84 
                 break;
 24690   
             default:
 24691  0 
                 NoViableAltException nvae =
 24692   
                     new NoViableAltException("", 143, 0, input);
 24693   
 
 24694  0 
                 throw nvae;
 24695   
 
 24696   
             }
 24697   
 
 24698  192 
             switch (alt143) {
 24699   
                 case 1 :
 24700   
                     // com\\googlecode\\sparkleg\\Sparql.g:682:7: BLANK_NODE_LABEL
 24701   
                     {
 24702  108 
                     root_0 = (Object)adaptor.nil();
 24703   
 
 24704   
 
 24705  108 
                     BLANK_NODE_LABEL683=(Token)match(input,BLANK_NODE_LABEL,FOLLOW_BLANK_NODE_LABEL_in_blankNode6960);
 24706  108 
                     BLANK_NODE_LABEL683_tree =
 24707   
                     (Object)adaptor.create(BLANK_NODE_LABEL683)
 24708   
                     ;
 24709  108 
                     adaptor.addChild(root_0, BLANK_NODE_LABEL683_tree);
 24710   
 
 24711   
 
 24712   
                     }
 24713  108 
                     break;
 24714   
                 case 2 :
 24715   
                     // com\\googlecode\\sparkleg\\Sparql.g:683:7: anon
 24716   
                     {
 24717  84 
                     root_0 = (Object)adaptor.nil();
 24718   
 
 24719   
 
 24720  84 
                     pushFollow(FOLLOW_anon_in_blankNode6968);
 24721  84 
                     anon684=anon();
 24722   
 
 24723  84 
                     state._fsp--;
 24724   
 
 24725  84 
                     adaptor.addChild(root_0, anon684.getTree());
 24726   
 
 24727   
                     }
 24728   
                     break;
 24729   
 
 24730   
             }
 24731  192 
             retval.stop = input.LT(-1);
 24732   
 
 24733   
 
 24734  192 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24735  192 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24736   
 
 24737   
         }
 24738  0 
         catch (RecognitionException re) {
 24739  0 
             reportError(re);
 24740  0 
             recover(input,re);
 24741  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24742   
 
 24743   
         }
 24744   
 
 24745  0 
         finally {
 24746   
                 // do for sure before leaving
 24747  192 
         }
 24748  192 
         return retval;
 24749   
     }
 24750   
     // $ANTLR end "blankNode"
 24751   
 
 24752   
 
 24753  84 
     public static class anon_return extends ParserRuleReturnScope {
 24754   
         Object tree;
 24755  84 
         public Object getTree() { return tree; }
 24756   
     };
 24757   
 
 24758   
 
 24759   
     // $ANTLR start "anon"
 24760   
     // com\\googlecode\\sparkleg\\Sparql.g:686:1: anon : OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET ;
 24761   
     public final SparqlParser.anon_return anon() throws RecognitionException {
 24762  84 
         SparqlParser.anon_return retval = new SparqlParser.anon_return();
 24763  84 
         retval.start = input.LT(1);
 24764   
 
 24765   
 
 24766  84 
         Object root_0 = null;
 24767   
 
 24768  84 
         Token OPEN_SQUARE_BRACKET685=null;
 24769  84 
         Token CLOSE_SQUARE_BRACKET686=null;
 24770   
 
 24771  84 
         Object OPEN_SQUARE_BRACKET685_tree=null;
 24772  84 
         Object CLOSE_SQUARE_BRACKET686_tree=null;
 24773   
 
 24774   
         try {
 24775   
             // com\\googlecode\\sparkleg\\Sparql.g:687:5: ( OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET )
 24776   
             // com\\googlecode\\sparkleg\\Sparql.g:687:7: OPEN_SQUARE_BRACKET CLOSE_SQUARE_BRACKET
 24777   
             {
 24778  84 
             root_0 = (Object)adaptor.nil();
 24779   
 
 24780   
 
 24781  84 
             OPEN_SQUARE_BRACKET685=(Token)match(input,OPEN_SQUARE_BRACKET,FOLLOW_OPEN_SQUARE_BRACKET_in_anon6985);
 24782  84 
             OPEN_SQUARE_BRACKET685_tree =
 24783   
             (Object)adaptor.create(OPEN_SQUARE_BRACKET685)
 24784   
             ;
 24785  84 
             adaptor.addChild(root_0, OPEN_SQUARE_BRACKET685_tree);
 24786   
 
 24787   
 
 24788  84 
             CLOSE_SQUARE_BRACKET686=(Token)match(input,CLOSE_SQUARE_BRACKET,FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6987);
 24789  84 
             CLOSE_SQUARE_BRACKET686_tree =
 24790   
             (Object)adaptor.create(CLOSE_SQUARE_BRACKET686)
 24791   
             ;
 24792  84 
             adaptor.addChild(root_0, CLOSE_SQUARE_BRACKET686_tree);
 24793   
 
 24794   
 
 24795   
             }
 24796   
 
 24797  84 
             retval.stop = input.LT(-1);
 24798   
 
 24799   
 
 24800  84 
             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
 24801  84 
             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
 24802   
 
 24803   
         }
 24804  0 
         catch (RecognitionException re) {
 24805  0 
             reportError(re);
 24806  0 
             recover(input,re);
 24807  0 
             retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
 24808   
 
 24809   
         }
 24810   
 
 24811  0 
         finally {
 24812   
                 // do for sure before leaving
 24813  84 
         }
 24814  84 
         return retval;
 24815   
     }
 24816   
     // $ANTLR end "anon"
 24817   
 
 24818   
     // Delegated rules
 24819   
 
 24820   
 
 24821  1898 
     protected DFA4 dfa4 = new DFA4(this);
 24822   
     static final String DFA4_eotS =
 24823   
         "\10\uffff";
 24824   
     static final String DFA4_eofS =
 24825   
         "\10\uffff";
 24826   
     static final String DFA4_minS =
 24827   
         "\1\6\1\133\1\u008a\2\uffff\1\6\1\133\1\6";
 24828   
     static final String DFA4_maxS =
 24829   
         "\1\u00cf\1\133\1\u008a\2\uffff\1\u00cf\1\133\1\u00cf";
 24830   
     static final String DFA4_acceptS =
 24831   
         "\3\uffff\1\1\1\2\3\uffff";
 24832   
     static final String DFA4_specialS =
 24833   
         "\10\uffff}>";
 24834  1 
     static final String[] DFA4_transitionS = {
 24835   
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24836   
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24837   
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24838   
             "\uffff\1\4",
 24839   
             "\1\5",
 24840   
             "\1\6",
 24841   
             "",
 24842   
             "",
 24843   
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24844   
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24845   
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24846   
             "\uffff\1\4",
 24847   
             "\1\7",
 24848   
             "\1\4\6\uffff\1\3\2\uffff\1\1\12\uffff\1\4\10\uffff\1\3\2\uffff"+
 24849   
             "\1\4\1\uffff\1\4\7\uffff\1\4\1\uffff\1\3\7\uffff\1\4\30\uffff"+
 24850   
             "\1\4\24\uffff\1\4\10\uffff\1\4\36\uffff\1\2\14\uffff\1\3\60"+
 24851   
             "\uffff\1\4"
 24852   
     };
 24853   
 
 24854  1 
     static final short[] DFA4_eot = DFA.unpackEncodedString(DFA4_eotS);
 24855  1 
     static final short[] DFA4_eof = DFA.unpackEncodedString(DFA4_eofS);
 24856  1 
     static final char[] DFA4_min = DFA.unpackEncodedStringToUnsignedChars(DFA4_minS);
 24857  1 
     static final char[] DFA4_max = DFA.unpackEncodedStringToUnsignedChars(DFA4_maxS);
 24858  1 
     static final short[] DFA4_accept = DFA.unpackEncodedString(DFA4_acceptS);
 24859  1 
     static final short[] DFA4_special = DFA.unpackEncodedString(DFA4_specialS);
 24860   
     static final short[][] DFA4_transition;
 24861   
 
 24862   
     static {
 24863  1 
         int numStates = DFA4_transitionS.length;
 24864  1 
         DFA4_transition = new short[numStates][];
 24865  9 
         for (int i=0; i<numStates; i++) {
 24866  8 
             DFA4_transition[i] = DFA.unpackEncodedString(DFA4_transitionS[i]);
 24867   
         }
 24868   
     }
 24869   
 
 24870   
     class DFA4 extends DFA {
 24871   
 
 24872  1898 
         public DFA4(BaseRecognizer recognizer) {
 24873  1898 
             this.recognizer = recognizer;
 24874  1898 
             this.decisionNumber = 4;
 24875  1898 
             this.eot = DFA4_eot;
 24876  1898 
             this.eof = DFA4_eof;
 24877  1898 
             this.min = DFA4_min;
 24878  1898 
             this.max = DFA4_max;
 24879  1898 
             this.accept = DFA4_accept;
 24880  1898 
             this.special = DFA4_special;
 24881  1898 
             this.transition = DFA4_transition;
 24882  1898 
         }
 24883   
         public String getDescription() {
 24884  0 
             return "76:1: query : ( prologue ( selectQuery | constructQuery | describeQuery | askQuery ) bindingsClause EOF -> ^( QUERY prologue ( selectQuery )* ( constructQuery )* ( describeQuery )* ( askQuery )* ) ( bindingsClause )* | update ( SEMICOLON ( update )? )* EOF -> ^( UPDATE ( update )+ ) );";
 24885   
         }
 24886   
     }
 24887   
 
 24888   
 
 24889  1 
     public static final BitSet FOLLOW_prologue_in_query155 = new BitSet(new long[]{0x0008001000002000L,0x0000000000000000L,0x0000000040000000L});
 24890  1 
     public static final BitSet FOLLOW_selectQuery_in_query158 = new BitSet(new long[]{0x0000000000040000L});
 24891  1 
     public static final BitSet FOLLOW_constructQuery_in_query162 = new BitSet(new long[]{0x0000000000040000L});
 24892  1 
     public static final BitSet FOLLOW_describeQuery_in_query166 = new BitSet(new long[]{0x0000000000040000L});
 24893  1 
     public static final BitSet FOLLOW_askQuery_in_query170 = new BitSet(new long[]{0x0000000000040000L});
 24894  1 
     public static final BitSet FOLLOW_bindingsClause_in_query173 = new BitSet(new long[]{0x0000000000000000L});
 24895  1 
     public static final BitSet FOLLOW_EOF_in_query175 = new BitSet(new long[]{0x0000000000000002L});
 24896  1 
     public static final BitSet FOLLOW_update_in_query206 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24897  1 
     public static final BitSet FOLLOW_SEMICOLON_in_query209 = new BitSet(new long[]{0x0802028008010040L,0x0004020000100000L,0x0000000100020000L,0x0000000000008000L});
 24898  1 
     public static final BitSet FOLLOW_update_in_query211 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000100000000L});
 24899  1 
     public static final BitSet FOLLOW_EOF_in_query216 = new BitSet(new long[]{0x0000000000000002L});
 24900  1 
     public static final BitSet FOLLOW_baseDecl_in_prologue249 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24901  1 
     public static final BitSet FOLLOW_prefixDecl_in_prologue253 = new BitSet(new long[]{0x0000000000010002L,0x0000000000000000L,0x0000000000020000L});
 24902  1 
     public static final BitSet FOLLOW_BASE_in_baseDecl284 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24903  1 
     public static final BitSet FOLLOW_IRI_REF_in_baseDecl286 = new BitSet(new long[]{0x0000000000000002L});
 24904  1 
     public static final BitSet FOLLOW_PREFIX_in_prefixDecl312 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000400L});
 24905  1 
     public static final BitSet FOLLOW_PNAME_NS_in_prefixDecl314 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
 24906  1 
     public static final BitSet FOLLOW_IRI_REF_in_prefixDecl316 = new BitSet(new long[]{0x0000000000000002L});
 24907  1 
     public static final BitSet FOLLOW_selectClause_in_selectQuery343 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24908  1 
     public static final BitSet FOLLOW_datasetClause_in_selectQuery345 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24909  1 
     public static final BitSet FOLLOW_whereClause_in_selectQuery348 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24910  1 
     public static final BitSet FOLLOW_solutionModifier_in_selectQuery350 = new BitSet(new long[]{0x0000000000000002L});
 24911  1 
     public static final BitSet FOLLOW_selectClause_in_subSelect384 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000002000L});
 24912  1 
     public static final BitSet FOLLOW_whereClause_in_subSelect386 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24913  1 
     public static final BitSet FOLLOW_solutionModifier_in_subSelect388 = new BitSet(new long[]{0x0000000000000002L});
 24914  1 
     public static final BitSet FOLLOW_SELECT_in_selectClause424 = new BitSet(new long[]{0x0020000000004000L,0x0000000000000000L,0x0000000000400000L});
 24915  1 
     public static final BitSet FOLLOW_DISTINCT_in_selectClause427 = new BitSet(new long[]{0x0000000000004000L});
 24916  1 
     public static final BitSet FOLLOW_REDUCED_in_selectClause431 = new BitSet(new long[]{0x0000000000004000L});
 24917  1 
     public static final BitSet FOLLOW_ASTERISK_in_selectClause435 = new BitSet(new long[]{0x0000000000000002L});
 24918  1 
     public static final BitSet FOLLOW_SELECT_in_selectClause457 = new BitSet(new long[]{0x0020000000000000L,0x0800000000000000L,0x0000000000400000L,0x0000000000000C00L});
 24919  1 
     public static final BitSet FOLLOW_DISTINCT_in_selectClause460 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24920  1 
     public static final BitSet FOLLOW_REDUCED_in_selectClause464 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24921  1 
     public static final BitSet FOLLOW_selectVariables_in_selectClause471 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24922  1 
     public static final BitSet FOLLOW_var_in_selectVariables506 = new BitSet(new long[]{0x0000000000000002L});
 24923  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_selectVariables523 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24924  1 
     public static final BitSet FOLLOW_expression_in_selectVariables525 = new BitSet(new long[]{0x0000000000000800L});
 24925  1 
     public static final BitSet FOLLOW_AS_in_selectVariables527 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24926  1 
     public static final BitSet FOLLOW_var_in_selectVariables529 = new BitSet(new long[]{0x0000000010000000L});
 24927  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_selectVariables531 = new BitSet(new long[]{0x0000000000000002L});
 24928  1 
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery558 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24929  1 
     public static final BitSet FOLLOW_constructTemplate_in_constructQuery560 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24930  1 
     public static final BitSet FOLLOW_datasetClause_in_constructQuery562 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24931  1 
     public static final BitSet FOLLOW_whereClause_in_constructQuery565 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24932  1 
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery567 = new BitSet(new long[]{0x0000000000000002L});
 24933  1 
     public static final BitSet FOLLOW_CONSTRUCT_in_constructQuery592 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24934  1 
     public static final BitSet FOLLOW_datasetClause_in_constructQuery594 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24935  1 
     public static final BitSet FOLLOW_WHERE_in_constructQuery597 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24936  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_constructQuery599 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24937  1 
     public static final BitSet FOLLOW_solutionModifier_in_constructQuery601 = new BitSet(new long[]{0x0000000000000002L});
 24938  1 
     public static final BitSet FOLLOW_DESCRIBE_in_describeQuery637 = new BitSet(new long[]{0x0000000000004000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 24939  1 
     public static final BitSet FOLLOW_varOrIRIref_in_describeQuery643 = new BitSet(new long[]{0x0000000000000000L,0x1400010008010840L,0x0000000000000601L,0x0000000000002C00L});
 24940  1 
     public static final BitSet FOLLOW_ASTERISK_in_describeQuery649 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24941  1 
     public static final BitSet FOLLOW_datasetClause_in_describeQuery652 = new BitSet(new long[]{0x0000000000000000L,0x1400010000010840L,0x0000000000000001L,0x0000000000002000L});
 24942  1 
     public static final BitSet FOLLOW_whereClause_in_describeQuery655 = new BitSet(new long[]{0x0000000000000000L,0x0400010000010800L,0x0000000000000001L});
 24943  1 
     public static final BitSet FOLLOW_solutionModifier_in_describeQuery658 = new BitSet(new long[]{0x0000000000000002L});
 24944  1 
     public static final BitSet FOLLOW_ASK_in_askQuery697 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24945  1 
     public static final BitSet FOLLOW_datasetClause_in_askQuery699 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000040L,0x0000000000000000L,0x0000000000002000L});
 24946  1 
     public static final BitSet FOLLOW_whereClause_in_askQuery702 = new BitSet(new long[]{0x0000000000000002L});
 24947  1 
     public static final BitSet FOLLOW_FROM_in_datasetClause730 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 24948  1 
     public static final BitSet FOLLOW_NAMED_in_datasetClause732 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 24949  1 
     public static final BitSet FOLLOW_iriRef_in_datasetClause735 = new BitSet(new long[]{0x0000000000000002L});
 24950  1 
     public static final BitSet FOLLOW_WHERE_in_whereClause763 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 24951  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_whereClause766 = new BitSet(new long[]{0x0000000000000002L});
 24952  1 
     public static final BitSet FOLLOW_groupClause_in_solutionModifier791 = new BitSet(new long[]{0x0000000000000002L,0x0400010000010000L,0x0000000000000001L});
 24953  1 
     public static final BitSet FOLLOW_havingClause_in_solutionModifier794 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L,0x0000000000000001L});
 24954  1 
     public static final BitSet FOLLOW_orderClause_in_solutionModifier797 = new BitSet(new long[]{0x0000000000000002L,0x0400010000000000L});
 24955  1 
     public static final BitSet FOLLOW_limitOffsetClauses_in_solutionModifier800 = new BitSet(new long[]{0x0000000000000002L});
 24956  1 
     public static final BitSet FOLLOW_GROUP_in_groupClause832 = new BitSet(new long[]{0x0000000002000000L});
 24957  1 
     public static final BitSet FOLLOW_BY_in_groupClause834 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24958  1 
     public static final BitSet FOLLOW_groupCondition_in_groupClause836 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24959  1 
     public static final BitSet FOLLOW_builtInCall_in_groupCondition870 = new BitSet(new long[]{0x0000000000000002L});
 24960  1 
     public static final BitSet FOLLOW_functionCall_in_groupCondition886 = new BitSet(new long[]{0x0000000000000002L});
 24961  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_groupCondition902 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 24962  1 
     public static final BitSet FOLLOW_expression_in_groupCondition904 = new BitSet(new long[]{0x0000000010000800L});
 24963  1 
     public static final BitSet FOLLOW_AS_in_groupCondition907 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24964  1 
     public static final BitSet FOLLOW_var_in_groupCondition909 = new BitSet(new long[]{0x0000000010000000L});
 24965  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_groupCondition913 = new BitSet(new long[]{0x0000000000000002L});
 24966  1 
     public static final BitSet FOLLOW_var_in_groupCondition932 = new BitSet(new long[]{0x0000000000000002L});
 24967  1 
     public static final BitSet FOLLOW_HAVING_in_havingClause961 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24968  1 
     public static final BitSet FOLLOW_constraint_in_havingClause963 = new BitSet(new long[]{0x2000184884C00022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 24969  1 
     public static final BitSet FOLLOW_ORDER_in_orderClause995 = new BitSet(new long[]{0x0000000002000000L});
 24970  1 
     public static final BitSet FOLLOW_BY_in_orderClause997 = new BitSet(new long[]{0x2004184884C01020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24971  1 
     public static final BitSet FOLLOW_orderCondition_in_orderClause999 = new BitSet(new long[]{0x2004184884C01022L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020C86L});
 24972  1 
     public static final BitSet FOLLOW_ASC_in_orderCondition1026 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24973  1 
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1028 = new BitSet(new long[]{0x0000000000000002L});
 24974  1 
     public static final BitSet FOLLOW_DESC_in_orderCondition1046 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 24975  1 
     public static final BitSet FOLLOW_brackettedExpression_in_orderCondition1048 = new BitSet(new long[]{0x0000000000000002L});
 24976  1 
     public static final BitSet FOLLOW_constraint_in_orderCondition1066 = new BitSet(new long[]{0x0000000000000002L});
 24977  1 
     public static final BitSet FOLLOW_var_in_orderCondition1082 = new BitSet(new long[]{0x0000000000000002L});
 24978  1 
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1112 = new BitSet(new long[]{0x0000000000000002L,0x0400000000000000L});
 24979  1 
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1114 = new BitSet(new long[]{0x0000000000000002L});
 24980  1 
     public static final BitSet FOLLOW_offsetClause_in_limitOffsetClauses1130 = new BitSet(new long[]{0x0000000000000002L,0x0000010000000000L});
 24981  1 
     public static final BitSet FOLLOW_limitClause_in_limitOffsetClauses1132 = new BitSet(new long[]{0x0000000000000002L});
 24982  1 
     public static final BitSet FOLLOW_LIMIT_in_limitClause1157 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24983  1 
     public static final BitSet FOLLOW_INTEGER_in_limitClause1159 = new BitSet(new long[]{0x0000000000000002L});
 24984  1 
     public static final BitSet FOLLOW_OFFSET_in_offsetClause1184 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 24985  1 
     public static final BitSet FOLLOW_INTEGER_in_offsetClause1186 = new BitSet(new long[]{0x0000000000000002L});
 24986  1 
     public static final BitSet FOLLOW_BINDINGS_in_bindingsClause1212 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24987  1 
     public static final BitSet FOLLOW_var_in_bindingsClause1214 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 24988  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_bindingsClause1217 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24989  1 
     public static final BitSet FOLLOW_bindingValueList_in_bindingsClause1219 = new BitSet(new long[]{0x0000000020000000L,0x0800000000000000L});
 24990  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_bindingsClause1222 = new BitSet(new long[]{0x0000000000000002L});
 24991  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_bindingValueList1258 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24992  1 
     public static final BitSet FOLLOW_bindingValue_in_bindingValueList1260 = new BitSet(new long[]{0x0700E00010000000L,0x0000000008E00008L,0x0007800000000600L,0x0000000000000011L});
 24993  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bindingValueList1263 = new BitSet(new long[]{0x0000000000000002L});
 24994  1 
     public static final BitSet FOLLOW_iriRef_in_bindingValue1294 = new BitSet(new long[]{0x0000000000000002L});
 24995  1 
     public static final BitSet FOLLOW_rdfLiteral_in_bindingValue1298 = new BitSet(new long[]{0x0000000000000002L});
 24996  1 
     public static final BitSet FOLLOW_numericLiteral_in_bindingValue1302 = new BitSet(new long[]{0x0000000000000002L});
 24997  1 
     public static final BitSet FOLLOW_booleanLiteral_in_bindingValue1306 = new BitSet(new long[]{0x0000000000000002L});
 24998  1 
     public static final BitSet FOLLOW_UNDEF_in_bindingValue1310 = new BitSet(new long[]{0x0000000000000002L});
 24999  1 
     public static final BitSet FOLLOW_prologue_in_update1331 = new BitSet(new long[]{0x0802028008000040L,0x0004020000100000L,0x0000000000000000L,0x0000000000008000L});
 25000  1 
     public static final BitSet FOLLOW_load_in_update1334 = new BitSet(new long[]{0x0000000000000002L});
 25001  1 
     public static final BitSet FOLLOW_clear_in_update1338 = new BitSet(new long[]{0x0000000000000002L});
 25002  1 
     public static final BitSet FOLLOW_drop_in_update1342 = new BitSet(new long[]{0x0000000000000002L});
 25003  1 
     public static final BitSet FOLLOW_add_in_update1346 = new BitSet(new long[]{0x0000000000000002L});
 25004  1 
     public static final BitSet FOLLOW_move_in_update1350 = new BitSet(new long[]{0x0000000000000002L});
 25005  1 
     public static final BitSet FOLLOW_copy_in_update1354 = new BitSet(new long[]{0x0000000000000002L});
 25006  1 
     public static final BitSet FOLLOW_create_in_update1358 = new BitSet(new long[]{0x0000000000000002L});
 25007  1 
     public static final BitSet FOLLOW_insert_in_update1362 = new BitSet(new long[]{0x0000000000000002L});
 25008  1 
     public static final BitSet FOLLOW_delete_in_update1366 = new BitSet(new long[]{0x0000000000000002L});
 25009  1 
     public static final BitSet FOLLOW_modify_in_update1370 = new BitSet(new long[]{0x0000000000000002L});
 25010  1 
     public static final BitSet FOLLOW_LOAD_in_load1433 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L});
 25011  1 
     public static final BitSet FOLLOW_SILENT_in_load1435 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25012  1 
     public static final BitSet FOLLOW_iriRef_in_load1438 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
 25013  1 
     public static final BitSet FOLLOW_INTO_in_load1441 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 25014  1 
     public static final BitSet FOLLOW_graphRef_in_load1443 = new BitSet(new long[]{0x0000000000000002L});
 25015  1 
     public static final BitSet FOLLOW_CLEAR_in_clear1480 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 25016  1 
     public static final BitSet FOLLOW_SILENT_in_clear1483 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 25017  1 
     public static final BitSet FOLLOW_graphRefAll_in_clear1486 = new BitSet(new long[]{0x0000000000000002L});
 25018  1 
     public static final BitSet FOLLOW_DROP_in_drop1518 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L,0x0000020000000000L});
 25019  1 
     public static final BitSet FOLLOW_SILENT_in_drop1520 = new BitSet(new long[]{0x0001000000000080L,0x0008000000000100L});
 25020  1 
     public static final BitSet FOLLOW_graphRefAll_in_drop1523 = new BitSet(new long[]{0x0000000000000002L});
 25021  1 
     public static final BitSet FOLLOW_CREATE_in_create1552 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L,0x0000020000000000L});
 25022  1 
     public static final BitSet FOLLOW_SILENT_in_create1554 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
 25023  1 
     public static final BitSet FOLLOW_graphRef_in_create1557 = new BitSet(new long[]{0x0000000000000002L});
 25024  1 
     public static final BitSet FOLLOW_ADD_in_add1589 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 25025  1 
     public static final BitSet FOLLOW_SILENT_in_add1591 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25026  1 
     public static final BitSet FOLLOW_graphOrDefault_in_add1596 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 25027  1 
     public static final BitSet FOLLOW_TO_in_add1598 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25028  1 
     public static final BitSet FOLLOW_graphOrDefault_in_add1602 = new BitSet(new long[]{0x0000000000000002L});
 25029  1 
     public static final BitSet FOLLOW_MOVE_in_move1638 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 25030  1 
     public static final BitSet FOLLOW_SILENT_in_move1640 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25031  1 
     public static final BitSet FOLLOW_graphOrDefault_in_move1645 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 25032  1 
     public static final BitSet FOLLOW_TO_in_move1647 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25033  1 
     public static final BitSet FOLLOW_graphOrDefault_in_move1651 = new BitSet(new long[]{0x0000000000000002L});
 25034  1 
     public static final BitSet FOLLOW_COPY_in_copy1687 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000020000000600L});
 25035  1 
     public static final BitSet FOLLOW_SILENT_in_copy1689 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25036  1 
     public static final BitSet FOLLOW_graphOrDefault_in_copy1694 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0800000000000000L});
 25037  1 
     public static final BitSet FOLLOW_TO_in_copy1696 = new BitSet(new long[]{0x0001000000000000L,0x0000000008000100L,0x0000000000000600L});
 25038  1 
     public static final BitSet FOLLOW_graphOrDefault_in_copy1700 = new BitSet(new long[]{0x0000000000000002L});
 25039  1 
     public static final BitSet FOLLOW_INSERT_in_insert1732 = new BitSet(new long[]{0x0000040000000000L});
 25040  1 
     public static final BitSet FOLLOW_DATA_in_insert1734 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25041  1 
     public static final BitSet FOLLOW_quadPattern_in_insert1736 = new BitSet(new long[]{0x0000000000000002L});
 25042  1 
     public static final BitSet FOLLOW_DELETE_in_delete1770 = new BitSet(new long[]{0x0000040000000000L});
 25043  1 
     public static final BitSet FOLLOW_deleteData_in_delete1772 = new BitSet(new long[]{0x0000000000000002L});
 25044  1 
     public static final BitSet FOLLOW_DELETE_in_delete1788 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002000L});
 25045  1 
     public static final BitSet FOLLOW_deleteWhere_in_delete1790 = new BitSet(new long[]{0x0000000000000002L});
 25046  1 
     public static final BitSet FOLLOW_DATA_in_deleteData1815 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25047  1 
     public static final BitSet FOLLOW_quadPattern_in_deleteData1817 = new BitSet(new long[]{0x0000000000000002L});
 25048  1 
     public static final BitSet FOLLOW_WHERE_in_deleteWhere1844 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25049  1 
     public static final BitSet FOLLOW_quadPattern_in_deleteWhere1846 = new BitSet(new long[]{0x0000000000000002L});
 25050  1 
     public static final BitSet FOLLOW_WITH_in_modify1878 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25051  1 
     public static final BitSet FOLLOW_iriRef_in_modify1880 = new BitSet(new long[]{0x0002000000000000L,0x0000000000100000L});
 25052  1 
     public static final BitSet FOLLOW_deleteClause_in_modify1885 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L,0x0000000000000000L,0x0000000000002100L});
 25053  1 
     public static final BitSet FOLLOW_insertClause_in_modify1887 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 25054  1 
     public static final BitSet FOLLOW_insertClause_in_modify1892 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 25055  1 
     public static final BitSet FOLLOW_usingClause_in_modify1895 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000002100L});
 25056  1 
     public static final BitSet FOLLOW_WHERE_in_modify1898 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25057  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_modify1900 = new BitSet(new long[]{0x0000000000000002L});
 25058  1 
     public static final BitSet FOLLOW_DELETE_in_deleteClause1947 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25059  1 
     public static final BitSet FOLLOW_quadPattern_in_deleteClause1949 = new BitSet(new long[]{0x0000000000000002L});
 25060  1 
     public static final BitSet FOLLOW_INSERT_in_insertClause1980 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25061  1 
     public static final BitSet FOLLOW_quadPattern_in_insertClause1982 = new BitSet(new long[]{0x0000000000000002L});
 25062  1 
     public static final BitSet FOLLOW_USING_in_usingClause2007 = new BitSet(new long[]{0x0000000000000000L,0x0008000008000000L,0x0000000000000600L});
 25063  1 
     public static final BitSet FOLLOW_NAMED_in_usingClause2009 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25064  1 
     public static final BitSet FOLLOW_iriRef_in_usingClause2012 = new BitSet(new long[]{0x0000000000000002L});
 25065  1 
     public static final BitSet FOLLOW_DEFAULT_in_graphOrDefault2043 = new BitSet(new long[]{0x0000000000000002L});
 25066  1 
     public static final BitSet FOLLOW_GRAPH_in_graphOrDefault2052 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25067  1 
     public static final BitSet FOLLOW_iriRef_in_graphOrDefault2055 = new BitSet(new long[]{0x0000000000000002L});
 25068  1 
     public static final BitSet FOLLOW_GRAPH_in_graphRef2082 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25069  1 
     public static final BitSet FOLLOW_iriRef_in_graphRef2084 = new BitSet(new long[]{0x0000000000000002L});
 25070  1 
     public static final BitSet FOLLOW_graphRef_in_graphRefAll2101 = new BitSet(new long[]{0x0000000000000002L});
 25071  1 
     public static final BitSet FOLLOW_DEFAULT_in_graphRefAll2105 = new BitSet(new long[]{0x0000000000000002L});
 25072  1 
     public static final BitSet FOLLOW_NAMED_in_graphRefAll2109 = new BitSet(new long[]{0x0000000000000002L});
 25073  1 
     public static final BitSet FOLLOW_ALL_in_graphRefAll2113 = new BitSet(new long[]{0x0000000000000002L});
 25074  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadPattern2130 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00108L,0x0007800000000600L,0x0000000000000C01L});
 25075  1 
     public static final BitSet FOLLOW_quads_in_quadPattern2132 = new BitSet(new long[]{0x0000000020000000L});
 25076  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadPattern2134 = new BitSet(new long[]{0x0000000000000002L});
 25077  1 
     public static final BitSet FOLLOW_triplesTemplate_in_quads2159 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 25078  1 
     public static final BitSet FOLLOW_quadsDetails_in_quads2162 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000100L});
 25079  1 
     public static final BitSet FOLLOW_quadsNotTriples_in_quadsDetails2194 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25080  1 
     public static final BitSet FOLLOW_DOT_in_quadsDetails2196 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25081  1 
     public static final BitSet FOLLOW_triplesTemplate_in_quadsDetails2199 = new BitSet(new long[]{0x0000000000000002L});
 25082  1 
     public static final BitSet FOLLOW_GRAPH_in_quadsNotTriples2229 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 25083  1 
     public static final BitSet FOLLOW_varOrIRIref_in_quadsNotTriples2231 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25084  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_quadsNotTriples2233 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25085  1 
     public static final BitSet FOLLOW_triplesTemplate_in_quadsNotTriples2235 = new BitSet(new long[]{0x0000000020000000L});
 25086  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_quadsNotTriples2238 = new BitSet(new long[]{0x0000000000000002L});
 25087  1 
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2270 = new BitSet(new long[]{0x0080000000000002L});
 25088  1 
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2273 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25089  1 
     public static final BitSet FOLLOW_triplesSameSubject_in_triplesTemplate2275 = new BitSet(new long[]{0x0080000000000002L});
 25090  1 
     public static final BitSet FOLLOW_DOT_in_triplesTemplate2279 = new BitSet(new long[]{0x0000000000000002L});
 25091  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2311 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000040000000L});
 25092  1 
     public static final BitSet FOLLOW_subSelect_in_groupGraphPattern2313 = new BitSet(new long[]{0x0000000020000000L});
 25093  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2315 = new BitSet(new long[]{0x0000000000000002L});
 25094  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2331 = new BitSet(new long[]{0x0700E00000220000L,0x7800400008E00118L,0x0007800400000600L,0x0000000000000C01L});
 25095  1 
     public static final BitSet FOLLOW_groupGraphPatternSub_in_groupGraphPattern2333 = new BitSet(new long[]{0x0000000020000000L});
 25096  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2335 = new BitSet(new long[]{0x0000000000000002L});
 25097  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_groupGraphPattern2351 = new BitSet(new long[]{0x0000000020000000L});
 25098  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_groupGraphPattern2353 = new BitSet(new long[]{0x0000000000000002L});
 25099  1 
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSub2382 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 25100  1 
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2384 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 25101  1 
     public static final BitSet FOLLOW_groupGraphPatternSubDetail_in_groupGraphPatternSub2400 = new BitSet(new long[]{0x0000000000020002L,0x5000400000000110L,0x0000000400000000L});
 25102  1 
     public static final BitSet FOLLOW_graphPatternNotTriples_in_groupGraphPatternSubDetail2423 = new BitSet(new long[]{0x0780E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25103  1 
     public static final BitSet FOLLOW_DOT_in_groupGraphPatternSubDetail2425 = new BitSet(new long[]{0x0700E00000200002L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25104  1 
     public static final BitSet FOLLOW_triplesBlock_in_groupGraphPatternSubDetail2428 = new BitSet(new long[]{0x0000000000000002L});
 25105  1 
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2453 = new BitSet(new long[]{0x0080000000000002L});
 25106  1 
     public static final BitSet FOLLOW_DOT_in_triplesBlock2456 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25107  1 
     public static final BitSet FOLLOW_triplesSameSubjectPath_in_triplesBlock2458 = new BitSet(new long[]{0x0080000000000002L});
 25108  1 
     public static final BitSet FOLLOW_DOT_in_triplesBlock2462 = new BitSet(new long[]{0x0000000000000002L});
 25109  1 
     public static final BitSet FOLLOW_groupOrUnionGraphPattern_in_graphPatternNotTriples2485 = new BitSet(new long[]{0x0000000000000002L});
 25110  1 
     public static final BitSet FOLLOW_optionalGraphPattern_in_graphPatternNotTriples2489 = new BitSet(new long[]{0x0000000000000002L});
 25111  1 
     public static final BitSet FOLLOW_minusGraphPattern_in_graphPatternNotTriples2493 = new BitSet(new long[]{0x0000000000000002L});
 25112  1 
     public static final BitSet FOLLOW_graphGraphPattern_in_graphPatternNotTriples2497 = new BitSet(new long[]{0x0000000000000002L});
 25113  1 
     public static final BitSet FOLLOW_serviceGraphPattern_in_graphPatternNotTriples2501 = new BitSet(new long[]{0x0000000000000002L});
 25114  1 
     public static final BitSet FOLLOW_filter_in_graphPatternNotTriples2505 = new BitSet(new long[]{0x0000000000000002L});
 25115  1 
     public static final BitSet FOLLOW_bind_in_graphPatternNotTriples2509 = new BitSet(new long[]{0x0000000000000002L});
 25116  1 
     public static final BitSet FOLLOW_OPTIONAL_in_optionalGraphPattern2526 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25117  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_optionalGraphPattern2528 = new BitSet(new long[]{0x0000000000000002L});
 25118  1 
     public static final BitSet FOLLOW_GRAPH_in_graphGraphPattern2553 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 25119  1 
     public static final BitSet FOLLOW_varOrIRIref_in_graphGraphPattern2555 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25120  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_graphGraphPattern2557 = new BitSet(new long[]{0x0000000000000002L});
 25121  1 
     public static final BitSet FOLLOW_SERVICE_in_serviceGraphPattern2584 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000020000000600L,0x0000000000000C00L});
 25122  1 
     public static final BitSet FOLLOW_SILENT_in_serviceGraphPattern2586 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L,0x0000000000000C00L});
 25123  1 
     public static final BitSet FOLLOW_varOrIRIref_in_serviceGraphPattern2589 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25124  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_serviceGraphPattern2591 = new BitSet(new long[]{0x0000000000000002L});
 25125  1 
     public static final BitSet FOLLOW_BIND_in_bind2625 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25126  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_bind2627 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25127  1 
     public static final BitSet FOLLOW_expression_in_bind2629 = new BitSet(new long[]{0x0000000000000800L});
 25128  1 
     public static final BitSet FOLLOW_AS_in_bind2631 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 25129  1 
     public static final BitSet FOLLOW_var_in_bind2633 = new BitSet(new long[]{0x0000000010000000L});
 25130  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_bind2635 = new BitSet(new long[]{0x0000000000000002L});
 25131  1 
     public static final BitSet FOLLOW_MINUS_KEYWORD_in_minusGraphPattern2672 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25132  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_minusGraphPattern2674 = new BitSet(new long[]{0x0000000000000002L});
 25133  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2702 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 25134  1 
     public static final BitSet FOLLOW_UNION_in_groupOrUnionGraphPattern2710 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25135  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_groupOrUnionGraphPattern2714 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000000L,0x0000000000000020L});
 25136  1 
     public static final BitSet FOLLOW_FILTER_in_filter2746 = new BitSet(new long[]{0x2000184884C00020L,0x0922882FEC060021L,0x05387CF82F200600L,0x0000000000020086L});
 25137  1 
     public static final BitSet FOLLOW_constraint_in_filter2748 = new BitSet(new long[]{0x0000000000000002L});
 25138  1 
     public static final BitSet FOLLOW_brackettedExpression_in_constraint2773 = new BitSet(new long[]{0x0000000000000002L});
 25139  1 
     public static final BitSet FOLLOW_builtInCall_in_constraint2781 = new BitSet(new long[]{0x0000000000000002L});
 25140  1 
     public static final BitSet FOLLOW_functionCall_in_constraint2789 = new BitSet(new long[]{0x0000000000000002L});
 25141  1 
     public static final BitSet FOLLOW_iriRef_in_functionCall2806 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25142  1 
     public static final BitSet FOLLOW_argList_in_functionCall2808 = new BitSet(new long[]{0x0000000000000002L});
 25143  1 
     public static final BitSet FOLLOW_nil_in_argList2839 = new BitSet(new long[]{0x0000000000000002L});
 25144  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_argList2851 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25145  1 
     public static final BitSet FOLLOW_DISTINCT_in_argList2853 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25146  1 
     public static final BitSet FOLLOW_expression_in_argList2856 = new BitSet(new long[]{0x0000000210000000L});
 25147  1 
     public static final BitSet FOLLOW_COMMA_in_argList2859 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25148  1 
     public static final BitSet FOLLOW_expression_in_argList2861 = new BitSet(new long[]{0x0000000210000000L});
 25149  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_argList2865 = new BitSet(new long[]{0x0000000000000002L});
 25150  1 
     public static final BitSet FOLLOW_nil_in_expressionList2891 = new BitSet(new long[]{0x0000000000000002L});
 25151  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_expressionList2895 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25152  1 
     public static final BitSet FOLLOW_expression_in_expressionList2897 = new BitSet(new long[]{0x0000000210000000L});
 25153  1 
     public static final BitSet FOLLOW_COMMA_in_expressionList2900 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25154  1 
     public static final BitSet FOLLOW_expression_in_expressionList2902 = new BitSet(new long[]{0x0000000210000000L});
 25155  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_expressionList2906 = new BitSet(new long[]{0x0000000000000002L});
 25156  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_constructTemplate2937 = new BitSet(new long[]{0x0700E00020200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25157  1 
     public static final BitSet FOLLOW_constructTriples_in_constructTemplate2939 = new BitSet(new long[]{0x0000000020000000L});
 25158  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_constructTemplate2942 = new BitSet(new long[]{0x0000000000000002L});
 25159  1 
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2968 = new BitSet(new long[]{0x0080000000000002L});
 25160  1 
     public static final BitSet FOLLOW_DOT_in_constructTriples2971 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25161  1 
     public static final BitSet FOLLOW_triplesSameSubject_in_constructTriples2973 = new BitSet(new long[]{0x0080000000000002L});
 25162  1 
     public static final BitSet FOLLOW_DOT_in_constructTriples2977 = new BitSet(new long[]{0x0000000000000002L});
 25163  1 
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubject3000 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25164  1 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3002 = new BitSet(new long[]{0x0000000000000002L});
 25165  1 
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubject3026 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25166  1 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubject3028 = new BitSet(new long[]{0x0000000000000002L});
 25167  1 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3058 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25168  1 
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmpty3061 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25169  1 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmpty3063 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25170  1 
     public static final BitSet FOLLOW_graphNode_in_objectList3089 = new BitSet(new long[]{0x0000000200000002L});
 25171  1 
     public static final BitSet FOLLOW_COMMA_in_objectList3092 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25172  1 
     public static final BitSet FOLLOW_graphNode_in_objectList3094 = new BitSet(new long[]{0x0000000200000002L});
 25173  1 
     public static final BitSet FOLLOW_varOrIRIref_in_verb3122 = new BitSet(new long[]{0x0000000000000002L});
 25174  1 
     public static final BitSet FOLLOW_A_in_verb3130 = new BitSet(new long[]{0x0000000000000002L});
 25175  1 
     public static final BitSet FOLLOW_varOrTerm_in_triplesSameSubjectPath3147 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25176  1 
     public static final BitSet FOLLOW_propertyListNotEmptyPath_in_triplesSameSubjectPath3149 = new BitSet(new long[]{0x0000000000000002L});
 25177  1 
     public static final BitSet FOLLOW_triplesNode_in_triplesSameSubjectPath3171 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25178  1 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesSameSubjectPath3173 = new BitSet(new long[]{0x0000000000000002L});
 25179  1 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3205 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25180  1 
     public static final BitSet FOLLOW_SEMICOLON_in_propertyListNotEmptyPath3208 = new BitSet(new long[]{0x0000000000000012L,0x081000000A000000L,0x0000000100000600L,0x0000000000000C00L});
 25181  1 
     public static final BitSet FOLLOW_propertyListNotEmptyDetails_in_propertyListNotEmptyPath3210 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000100000000L});
 25182  1 
     public static final BitSet FOLLOW_verbSimpleOrPath_in_propertyListNotEmptyDetails3237 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25183  1 
     public static final BitSet FOLLOW_objectList_in_propertyListNotEmptyDetails3239 = new BitSet(new long[]{0x0000000000000002L});
 25184  1 
     public static final BitSet FOLLOW_verbPath_in_verbSimpleOrPath3269 = new BitSet(new long[]{0x0000000000000002L});
 25185  1 
     public static final BitSet FOLLOW_verbSimple_in_verbSimpleOrPath3277 = new BitSet(new long[]{0x0000000000000002L});
 25186  1 
     public static final BitSet FOLLOW_path_in_verbPath3296 = new BitSet(new long[]{0x0000000000000002L});
 25187  1 
     public static final BitSet FOLLOW_var_in_verbSimple3317 = new BitSet(new long[]{0x0000000000000002L});
 25188  1 
     public static final BitSet FOLLOW_pathSequence_in_path3339 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25189  1 
     public static final BitSet FOLLOW_PIPE_in_path3342 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25190  1 
     public static final BitSet FOLLOW_pathSequence_in_path3344 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000000L,0x0000000000000080L});
 25191  1 
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3373 = new BitSet(new long[]{0x0040000000000002L});
 25192  1 
     public static final BitSet FOLLOW_DIVIDE_in_pathSequence3376 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25193  1 
     public static final BitSet FOLLOW_pathEltOrInverse_in_pathSequence3378 = new BitSet(new long[]{0x0040000000000002L});
 25194  1 
     public static final BitSet FOLLOW_INVERSE_in_pathEltOrInverse3406 = new BitSet(new long[]{0x0000000000000010L,0x0810000008000000L,0x0000000000000600L});
 25195  1 
     public static final BitSet FOLLOW_pathElt_in_pathEltOrInverse3409 = new BitSet(new long[]{0x0000000000000002L});
 25196  1 
     public static final BitSet FOLLOW_pathPrimary_in_pathElt3437 = new BitSet(new long[]{0x0000000000004002L,0x1000000000000000L,0x0000000000100100L});
 25197  1 
     public static final BitSet FOLLOW_pathMod_in_pathElt3439 = new BitSet(new long[]{0x0000000000000002L});
 25198  1 
     public static final BitSet FOLLOW_ASTERISK_in_pathMod3458 = new BitSet(new long[]{0x0000000000000002L});
 25199  1 
     public static final BitSet FOLLOW_QUESTION_MARK_in_pathMod3462 = new BitSet(new long[]{0x0000000000000002L});
 25200  1 
     public static final BitSet FOLLOW_PLUS_in_pathMod3466 = new BitSet(new long[]{0x0000000000000002L});
 25201  1 
     public static final BitSet FOLLOW_OPEN_CURLY_BRACE_in_pathMod3470 = new BitSet(new long[]{0x0000000200000000L,0x0000000000200000L});
 25202  1 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3473 = new BitSet(new long[]{0x0000000220000000L});
 25203  1 
     public static final BitSet FOLLOW_COMMA_in_pathMod3476 = new BitSet(new long[]{0x0000000020000000L,0x0000000000200000L});
 25204  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3479 = new BitSet(new long[]{0x0000000000000002L});
 25205  1 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3483 = new BitSet(new long[]{0x0000000020000000L});
 25206  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3485 = new BitSet(new long[]{0x0000000000000002L});
 25207  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3490 = new BitSet(new long[]{0x0000000000000002L});
 25208  1 
     public static final BitSet FOLLOW_COMMA_in_pathMod3495 = new BitSet(new long[]{0x0000000000000000L,0x0000000000200000L});
 25209  1 
     public static final BitSet FOLLOW_INTEGER_in_pathMod3497 = new BitSet(new long[]{0x0000000020000000L});
 25210  1 
     public static final BitSet FOLLOW_CLOSE_CURLY_BRACE_in_pathMod3499 = new BitSet(new long[]{0x0000000000000002L});
 25211  1 
     public static final BitSet FOLLOW_iriRef_in_pathPrimary3518 = new BitSet(new long[]{0x0000000000000002L});
 25212  1 
     public static final BitSet FOLLOW_A_in_pathPrimary3534 = new BitSet(new long[]{0x0000000000000002L});
 25213  1 
     public static final BitSet FOLLOW_NEGATION_in_pathPrimary3550 = new BitSet(new long[]{0x0000000000000010L,0x080000000A000000L,0x0000000000000600L});
 25214  1 
     public static final BitSet FOLLOW_pathNegatedPropertySet_in_pathPrimary3552 = new BitSet(new long[]{0x0000000000000002L});
 25215  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathPrimary3570 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L});
 25216  1 
     public static final BitSet FOLLOW_path_in_pathPrimary3572 = new BitSet(new long[]{0x0000000010000000L});
 25217  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathPrimary3574 = new BitSet(new long[]{0x0000000000000002L});
 25218  1 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3599 = new BitSet(new long[]{0x0000000000000002L});
 25219  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_pathNegatedPropertySet3615 = new BitSet(new long[]{0x0000000010000010L,0x000000000A000000L,0x0000000000000600L});
 25220  1 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3618 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25221  1 
     public static final BitSet FOLLOW_PIPE_in_pathNegatedPropertySet3621 = new BitSet(new long[]{0x0000000000000010L,0x000000000A000000L,0x0000000000000600L});
 25222  1 
     public static final BitSet FOLLOW_pathOneInPropertySet_in_pathNegatedPropertySet3623 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000000000080L});
 25223  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_pathNegatedPropertySet3629 = new BitSet(new long[]{0x0000000000000002L});
 25224  1 
     public static final BitSet FOLLOW_INVERSE_in_pathOneInPropertySet3658 = new BitSet(new long[]{0x0000000000000010L,0x0000000008000000L,0x0000000000000600L});
 25225  1 
     public static final BitSet FOLLOW_iriRef_in_pathOneInPropertySet3662 = new BitSet(new long[]{0x0000000000000002L});
 25226  1 
     public static final BitSet FOLLOW_A_in_pathOneInPropertySet3666 = new BitSet(new long[]{0x0000000000000002L});
 25227  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_triplesNode3685 = new BitSet(new long[]{0x0700E00000200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25228  1 
     public static final BitSet FOLLOW_graphNode_in_triplesNode3687 = new BitSet(new long[]{0x0700E00010200000L,0x2800000008E00008L,0x0007800000000600L,0x0000000000000C01L});
 25229  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_triplesNode3690 = new BitSet(new long[]{0x0000000000000002L});
 25230  1 
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_triplesNode3707 = new BitSet(new long[]{0x0000000000000010L,0x081000000A000000L,0x0000000000000600L,0x0000000000000C00L});
 25231  1 
     public static final BitSet FOLLOW_propertyListNotEmpty_in_triplesNode3709 = new BitSet(new long[]{0x0000000040000000L});
 25232  1 
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_triplesNode3711 = new BitSet(new long[]{0x0000000000000002L});
 25233  1 
     public static final BitSet FOLLOW_varOrTerm_in_graphNode3736 = new BitSet(new long[]{0x0000000000000002L});
 25234  1 
     public static final BitSet FOLLOW_triplesNode_in_graphNode3740 = new BitSet(new long[]{0x0000000000000002L});
 25235  1 
     public static final BitSet FOLLOW_var_in_varOrTerm3757 = new BitSet(new long[]{0x0000000000000002L});
 25236  1 
     public static final BitSet FOLLOW_graphTerm_in_varOrTerm3765 = new BitSet(new long[]{0x0000000000000002L});
 25237  1 
     public static final BitSet FOLLOW_var_in_varOrIRIref3782 = new BitSet(new long[]{0x0000000000000002L});
 25238  1 
     public static final BitSet FOLLOW_iriRef_in_varOrIRIref3786 = new BitSet(new long[]{0x0000000000000002L});
 25239  1 
     public static final BitSet FOLLOW_iriRef_in_graphTerm3824 = new BitSet(new long[]{0x0000000000000002L});
 25240  1 
     public static final BitSet FOLLOW_rdfLiteral_in_graphTerm3832 = new BitSet(new long[]{0x0000000000000002L});
 25241  1 
     public static final BitSet FOLLOW_numericLiteral_in_graphTerm3840 = new BitSet(new long[]{0x0000000000000002L});
 25242  1 
     public static final BitSet FOLLOW_booleanLiteral_in_graphTerm3848 = new BitSet(new long[]{0x0000000000000002L});
 25243  1 
     public static final BitSet FOLLOW_blankNode_in_graphTerm3856 = new BitSet(new long[]{0x0000000000000002L});
 25244  1 
     public static final BitSet FOLLOW_nil_in_graphTerm3864 = new BitSet(new long[]{0x0000000000000002L});
 25245  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_nil3885 = new BitSet(new long[]{0x0000000010000000L});
 25246  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_nil3887 = new BitSet(new long[]{0x0000000000000002L});
 25247  1 
     public static final BitSet FOLLOW_conditionalOrExpression_in_expression3904 = new BitSet(new long[]{0x0000000000000002L});
 25248  1 
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3924 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25249  1 
     public static final BitSet FOLLOW_OR_in_conditionalOrExpression3933 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25250  1 
     public static final BitSet FOLLOW_conditionalAndExpression_in_conditionalOrExpression3937 = new BitSet(new long[]{0x0000000000000002L,0x8000000000000000L});
 25251  1 
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3971 = new BitSet(new long[]{0x0000000000000102L});
 25252  1 
     public static final BitSet FOLLOW_AND_in_conditionalAndExpression3980 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25253  1 
     public static final BitSet FOLLOW_valueLogical_in_conditionalAndExpression3984 = new BitSet(new long[]{0x0000000000000102L});
 25254  1 
     public static final BitSet FOLLOW_relationalExpression_in_valueLogical4015 = new BitSet(new long[]{0x0000000000000002L});
 25255  1 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4035 = new BitSet(new long[]{0x8000000000000002L,0x006000C000080600L});
 25256  1 
     public static final BitSet FOLLOW_EQUAL_in_relationalExpression4045 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25257  1 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4049 = new BitSet(new long[]{0x0000000000000002L});
 25258  1 
     public static final BitSet FOLLOW_NOT_EQUAL_in_relationalExpression4106 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25259  1 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4110 = new BitSet(new long[]{0x0000000000000002L});
 25260  1 
     public static final BitSet FOLLOW_LESS_in_relationalExpression4165 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25261  1 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4169 = new BitSet(new long[]{0x0000000000000002L});
 25262  1 
     public static final BitSet FOLLOW_GREATER_in_relationalExpression4224 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25263  1 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4228 = new BitSet(new long[]{0x0000000000000002L});
 25264  1 
     public static final BitSet FOLLOW_LESS_EQUAL_in_relationalExpression4282 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25265  1 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4286 = new BitSet(new long[]{0x0000000000000002L});
 25266  1 
     public static final BitSet FOLLOW_GREATER_EQUAL_in_relationalExpression4340 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25267  1 
     public static final BitSet FOLLOW_numericExpression_in_relationalExpression4344 = new BitSet(new long[]{0x0000000000000002L});
 25268  1 
     public static final BitSet FOLLOW_IN_in_relationalExpression4400 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25269  1 
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4404 = new BitSet(new long[]{0x0000000000000002L});
 25270  1 
     public static final BitSet FOLLOW_NOT_in_relationalExpression4458 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
 25271  1 
     public static final BitSet FOLLOW_IN_in_relationalExpression4460 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25272  1 
     public static final BitSet FOLLOW_expressionList_in_relationalExpression4464 = new BitSet(new long[]{0x0000000000000002L});
 25273  1 
     public static final BitSet FOLLOW_additiveExpression_in_numericExpression4498 = new BitSet(new long[]{0x0000000000000002L});
 25274  1 
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4518 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25275  1 
     public static final BitSet FOLLOW_additiveOperator_in_additiveExpression4528 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25276  1 
     public static final BitSet FOLLOW_multiplicativeExpression_in_additiveExpression4532 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25277  1 
     public static final BitSet FOLLOW_numericLiteralPositive_in_additiveExpression4599 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25278  1 
     public static final BitSet FOLLOW_numericLiteralNegative_in_additiveExpression4617 = new BitSet(new long[]{0x0640C00000004002L,0x0000200000C00000L,0x0000000000000100L});
 25279  1 
     public static final BitSet FOLLOW_ASTERISK_in_additiveExpression4681 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25280  1 
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4685 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25281  1 
     public static final BitSet FOLLOW_DIVIDE_in_additiveExpression4751 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25282  1 
     public static final BitSet FOLLOW_unaryExpression_in_additiveExpression4755 = new BitSet(new long[]{0x0600C00000000002L,0x0000200000C00000L,0x0000000000000100L});
 25283  1 
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4821 = new BitSet(new long[]{0x0040000000004002L});
 25284  1 
     public static final BitSet FOLLOW_multiplicativeOperator_in_multiplicativeExpression4830 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25285  1 
     public static final BitSet FOLLOW_unaryExpression_in_multiplicativeExpression4834 = new BitSet(new long[]{0x0040000000004002L});
 25286  1 
     public static final BitSet FOLLOW_NEGATION_in_unaryExpression4890 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25287  1 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4892 = new BitSet(new long[]{0x0000000000000002L});
 25288  1 
     public static final BitSet FOLLOW_PLUS_in_unaryExpression4910 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25289  1 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4912 = new BitSet(new long[]{0x0000000000000002L});
 25290  1 
     public static final BitSet FOLLOW_MINUS_in_unaryExpression4930 = new BitSet(new long[]{0x2700F94884C08020L,0x09229C2FECE62029L,0x073FFCF83F200600L,0x0000000000020C87L});
 25291  1 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4932 = new BitSet(new long[]{0x0000000000000002L});
 25292  1 
     public static final BitSet FOLLOW_primaryExpression_in_unaryExpression4950 = new BitSet(new long[]{0x0000000000000002L});
 25293  1 
     public static final BitSet FOLLOW_brackettedExpression_in_primaryExpression4975 = new BitSet(new long[]{0x0000000000000002L});
 25294  1 
     public static final BitSet FOLLOW_builtInCall_in_primaryExpression4979 = new BitSet(new long[]{0x0000000000000002L});
 25295  1 
     public static final BitSet FOLLOW_iriRefOrFunction_in_primaryExpression4983 = new BitSet(new long[]{0x0000000000000002L});
 25296  1 
     public static final BitSet FOLLOW_rdfLiteral_in_primaryExpression4987 = new BitSet(new long[]{0x0000000000000002L});
 25297  1 
     public static final BitSet FOLLOW_numericLiteral_in_primaryExpression4991 = new BitSet(new long[]{0x0000000000000002L});
 25298  1 
     public static final BitSet FOLLOW_booleanLiteral_in_primaryExpression4995 = new BitSet(new long[]{0x0000000000000002L});
 25299  1 
     public static final BitSet FOLLOW_var_in_primaryExpression4999 = new BitSet(new long[]{0x0000000000000002L});
 25300  1 
     public static final BitSet FOLLOW_aggregate_in_primaryExpression5003 = new BitSet(new long[]{0x0000000000000002L});
 25301  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_brackettedExpression5020 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25302  1 
     public static final BitSet FOLLOW_expression_in_brackettedExpression5022 = new BitSet(new long[]{0x0000000010000000L});
 25303  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_brackettedExpression5024 = new BitSet(new long[]{0x0000000000000002L});
 25304  1 
     public static final BitSet FOLLOW_STR_in_builtInCall5049 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25305  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5051 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25306  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5053 = new BitSet(new long[]{0x0000000010000000L});
 25307  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5055 = new BitSet(new long[]{0x0000000000000002L});
 25308  1 
     public static final BitSet FOLLOW_LANG_in_builtInCall5071 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25309  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5073 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25310  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5075 = new BitSet(new long[]{0x0000000010000000L});
 25311  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5077 = new BitSet(new long[]{0x0000000000000002L});
 25312  1 
     public static final BitSet FOLLOW_LANGMATCHES_in_builtInCall5093 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25313  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5095 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25314  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5097 = new BitSet(new long[]{0x0000000200000000L});
 25315  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5099 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25316  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5101 = new BitSet(new long[]{0x0000000010000000L});
 25317  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5103 = new BitSet(new long[]{0x0000000000000002L});
 25318  1 
     public static final BitSet FOLLOW_DATATYPE_in_builtInCall5120 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25319  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5122 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25320  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5124 = new BitSet(new long[]{0x0000000010000000L});
 25321  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5126 = new BitSet(new long[]{0x0000000000000002L});
 25322  1 
     public static final BitSet FOLLOW_BOUND_in_builtInCall5142 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25323  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5144 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000000000000L,0x0000000000000C00L});
 25324  1 
     public static final BitSet FOLLOW_var_in_builtInCall5146 = new BitSet(new long[]{0x0000000010000000L});
 25325  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5148 = new BitSet(new long[]{0x0000000000000002L});
 25326  1 
     public static final BitSet FOLLOW_IRI_in_builtInCall5164 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25327  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5166 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25328  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5168 = new BitSet(new long[]{0x0000000010000000L});
 25329  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5170 = new BitSet(new long[]{0x0000000000000002L});
 25330  1 
     public static final BitSet FOLLOW_URI_in_builtInCall5186 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25331  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5188 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25332  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5190 = new BitSet(new long[]{0x0000000010000000L});
 25333  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5192 = new BitSet(new long[]{0x0000000000000002L});
 25334  1 
     public static final BitSet FOLLOW_BNODE_in_builtInCall5208 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25335  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5211 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25336  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5213 = new BitSet(new long[]{0x0000000010000000L});
 25337  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5215 = new BitSet(new long[]{0x0000000000000002L});
 25338  1 
     public static final BitSet FOLLOW_BNODE_in_builtInCall5232 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25339  1 
     public static final BitSet FOLLOW_nil_in_builtInCall5234 = new BitSet(new long[]{0x0000000000000002L});
 25340  1 
     public static final BitSet FOLLOW_RAND_in_builtInCall5246 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25341  1 
     public static final BitSet FOLLOW_nil_in_builtInCall5248 = new BitSet(new long[]{0x0000000000000002L});
 25342  1 
     public static final BitSet FOLLOW_ABS_in_builtInCall5260 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25343  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5262 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25344  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5264 = new BitSet(new long[]{0x0000000010000000L});
 25345  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5266 = new BitSet(new long[]{0x0000000000000002L});
 25346  1 
     public static final BitSet FOLLOW_CEIL_in_builtInCall5282 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25347  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5284 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25348  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5286 = new BitSet(new long[]{0x0000000010000000L});
 25349  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5288 = new BitSet(new long[]{0x0000000000000002L});
 25350  1 
     public static final BitSet FOLLOW_FLOOR_in_builtInCall5304 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25351  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5306 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25352  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5308 = new BitSet(new long[]{0x0000000010000000L});
 25353  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5310 = new BitSet(new long[]{0x0000000000000002L});
 25354  1 
     public static final BitSet FOLLOW_ROUND_in_builtInCall5326 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25355  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5328 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25356  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5330 = new BitSet(new long[]{0x0000000010000000L});
 25357  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5332 = new BitSet(new long[]{0x0000000000000002L});
 25358  1 
     public static final BitSet FOLLOW_CONCAT_in_builtInCall5348 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25359  1 
     public static final BitSet FOLLOW_expressionList_in_builtInCall5350 = new BitSet(new long[]{0x0000000000000002L});
 25360  1 
     public static final BitSet FOLLOW_subStringExpression_in_builtInCall5366 = new BitSet(new long[]{0x0000000000000002L});
 25361  1 
     public static final BitSet FOLLOW_STRLEN_in_builtInCall5378 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25362  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5380 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25363  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5382 = new BitSet(new long[]{0x0000000010000000L});
 25364  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5384 = new BitSet(new long[]{0x0000000000000002L});
 25365  1 
     public static final BitSet FOLLOW_UCASE_in_builtInCall5400 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25366  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5402 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25367  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5404 = new BitSet(new long[]{0x0000000010000000L});
 25368  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5406 = new BitSet(new long[]{0x0000000000000002L});
 25369  1 
     public static final BitSet FOLLOW_LCASE_in_builtInCall5422 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25370  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5424 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25371  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5426 = new BitSet(new long[]{0x0000000010000000L});
 25372  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5428 = new BitSet(new long[]{0x0000000000000002L});
 25373  1 
     public static final BitSet FOLLOW_ENCODE_FOR_URI_in_builtInCall5444 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25374  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5446 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25375  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5448 = new BitSet(new long[]{0x0000000010000000L});
 25376  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5450 = new BitSet(new long[]{0x0000000000000002L});
 25377  1 
     public static final BitSet FOLLOW_CONTAINS_in_builtInCall5466 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25378  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5468 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25379  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5470 = new BitSet(new long[]{0x0000000200000000L});
 25380  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5472 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25381  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5474 = new BitSet(new long[]{0x0000000010000000L});
 25382  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5476 = new BitSet(new long[]{0x0000000000000002L});
 25383  1 
     public static final BitSet FOLLOW_STRSTARTS_in_builtInCall5494 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25384  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5496 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25385  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5498 = new BitSet(new long[]{0x0000000200000000L});
 25386  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5500 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25387  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5502 = new BitSet(new long[]{0x0000000010000000L});
 25388  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5504 = new BitSet(new long[]{0x0000000000000002L});
 25389  1 
     public static final BitSet FOLLOW_STRENDS_in_builtInCall5522 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25390  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5524 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25391  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5526 = new BitSet(new long[]{0x0000000200000000L});
 25392  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5528 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25393  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5530 = new BitSet(new long[]{0x0000000010000000L});
 25394  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5532 = new BitSet(new long[]{0x0000000000000002L});
 25395  1 
     public static final BitSet FOLLOW_STRBEFORE_in_builtInCall5550 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25396  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5552 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25397  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5554 = new BitSet(new long[]{0x0000000200000000L});
 25398  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5556 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25399  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5558 = new BitSet(new long[]{0x0000000010000000L});
 25400  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5560 = new BitSet(new long[]{0x0000000000000002L});
 25401  1 
     public static final BitSet FOLLOW_STRAFTER_in_builtInCall5578 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25402  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5580 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25403  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5582 = new BitSet(new long[]{0x0000000200000000L});
 25404  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5584 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25405  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5586 = new BitSet(new long[]{0x0000000010000000L});
 25406  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5588 = new BitSet(new long[]{0x0000000000000002L});
 25407  1 
     public static final BitSet FOLLOW_REPLACE_in_builtInCall5606 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25408  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5608 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25409  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5610 = new BitSet(new long[]{0x0000000200000000L});
 25410  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5612 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25411  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5614 = new BitSet(new long[]{0x0000000200000000L});
 25412  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5616 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25413  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5618 = new BitSet(new long[]{0x0000000010000000L});
 25414  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5620 = new BitSet(new long[]{0x0000000000000002L});
 25415  1 
     public static final BitSet FOLLOW_YEAR_in_builtInCall5640 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25416  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5642 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25417  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5644 = new BitSet(new long[]{0x0000000010000000L});
 25418  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5646 = new BitSet(new long[]{0x0000000000000002L});
 25419  1 
     public static final BitSet FOLLOW_MONTH_in_builtInCall5662 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25420  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5664 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25421  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5666 = new BitSet(new long[]{0x0000000010000000L});
 25422  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5668 = new BitSet(new long[]{0x0000000000000002L});
 25423  1 
     public static final BitSet FOLLOW_DAY_in_builtInCall5684 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25424  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5686 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25425  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5688 = new BitSet(new long[]{0x0000000010000000L});
 25426  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5690 = new BitSet(new long[]{0x0000000000000002L});
 25427  1 
     public static final BitSet FOLLOW_HOURS_in_builtInCall5706 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25428  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5708 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25429  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5710 = new BitSet(new long[]{0x0000000010000000L});
 25430  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5712 = new BitSet(new long[]{0x0000000000000002L});
 25431  1 
     public static final BitSet FOLLOW_MINUTES_in_builtInCall5728 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25432  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5730 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25433  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5732 = new BitSet(new long[]{0x0000000010000000L});
 25434  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5734 = new BitSet(new long[]{0x0000000000000002L});
 25435  1 
     public static final BitSet FOLLOW_SECONDS_in_builtInCall5750 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25436  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5752 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25437  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5754 = new BitSet(new long[]{0x0000000010000000L});
 25438  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5756 = new BitSet(new long[]{0x0000000000000002L});
 25439  1 
     public static final BitSet FOLLOW_TIMEZONE_in_builtInCall5772 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25440  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5774 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25441  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5776 = new BitSet(new long[]{0x0000000010000000L});
 25442  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5778 = new BitSet(new long[]{0x0000000000000002L});
 25443  1 
     public static final BitSet FOLLOW_TZ_in_builtInCall5794 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25444  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5796 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25445  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5798 = new BitSet(new long[]{0x0000000010000000L});
 25446  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5800 = new BitSet(new long[]{0x0000000000000002L});
 25447  1 
     public static final BitSet FOLLOW_NOW_in_builtInCall5816 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25448  1 
     public static final BitSet FOLLOW_nil_in_builtInCall5818 = new BitSet(new long[]{0x0000000000000002L});
 25449  1 
     public static final BitSet FOLLOW_MD5_in_builtInCall5830 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25450  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5832 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25451  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5834 = new BitSet(new long[]{0x0000000010000000L});
 25452  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5836 = new BitSet(new long[]{0x0000000000000002L});
 25453  1 
     public static final BitSet FOLLOW_SHA1_in_builtInCall5852 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25454  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5854 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25455  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5856 = new BitSet(new long[]{0x0000000010000000L});
 25456  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5858 = new BitSet(new long[]{0x0000000000000002L});
 25457  1 
     public static final BitSet FOLLOW_SHA224_in_builtInCall5874 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25458  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5876 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25459  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5878 = new BitSet(new long[]{0x0000000010000000L});
 25460  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5880 = new BitSet(new long[]{0x0000000000000002L});
 25461  1 
     public static final BitSet FOLLOW_SHA256_in_builtInCall5896 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25462  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5898 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25463  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5900 = new BitSet(new long[]{0x0000000010000000L});
 25464  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5902 = new BitSet(new long[]{0x0000000000000002L});
 25465  1 
     public static final BitSet FOLLOW_SHA384_in_builtInCall5918 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25466  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5920 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25467  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5922 = new BitSet(new long[]{0x0000000010000000L});
 25468  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5924 = new BitSet(new long[]{0x0000000000000002L});
 25469  1 
     public static final BitSet FOLLOW_SHA512_in_builtInCall5940 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25470  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5942 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25471  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5944 = new BitSet(new long[]{0x0000000010000000L});
 25472  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall5946 = new BitSet(new long[]{0x0000000000000002L});
 25473  1 
     public static final BitSet FOLLOW_COALESCE_in_builtInCall5962 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25474  1 
     public static final BitSet FOLLOW_expressionList_in_builtInCall5964 = new BitSet(new long[]{0x0000000000000002L});
 25475  1 
     public static final BitSet FOLLOW_IF_in_builtInCall5980 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25476  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall5982 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25477  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5986 = new BitSet(new long[]{0x0000000200000000L});
 25478  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5988 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25479  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5992 = new BitSet(new long[]{0x0000000200000000L});
 25480  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall5994 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25481  1 
     public static final BitSet FOLLOW_expression_in_builtInCall5998 = new BitSet(new long[]{0x0000000010000000L});
 25482  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6000 = new BitSet(new long[]{0x0000000000000002L});
 25483  1 
     public static final BitSet FOLLOW_STRLANG_in_builtInCall6023 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25484  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6025 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25485  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6027 = new BitSet(new long[]{0x0000000200000000L});
 25486  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall6029 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25487  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6031 = new BitSet(new long[]{0x0000000010000000L});
 25488  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6033 = new BitSet(new long[]{0x0000000000000002L});
 25489  1 
     public static final BitSet FOLLOW_STRDT_in_builtInCall6051 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25490  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6053 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25491  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6055 = new BitSet(new long[]{0x0000000200000000L});
 25492  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall6057 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25493  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6059 = new BitSet(new long[]{0x0000000010000000L});
 25494  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6061 = new BitSet(new long[]{0x0000000000000002L});
 25495  1 
     public static final BitSet FOLLOW_SAMETERM_in_builtInCall6079 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25496  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6081 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25497  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6083 = new BitSet(new long[]{0x0000000200000000L});
 25498  1 
     public static final BitSet FOLLOW_COMMA_in_builtInCall6085 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25499  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6087 = new BitSet(new long[]{0x0000000010000000L});
 25500  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6089 = new BitSet(new long[]{0x0000000000000002L});
 25501  1 
     public static final BitSet FOLLOW_ISIRI_in_builtInCall6107 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25502  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6109 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25503  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6111 = new BitSet(new long[]{0x0000000010000000L});
 25504  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6113 = new BitSet(new long[]{0x0000000000000002L});
 25505  1 
     public static final BitSet FOLLOW_ISURI_in_builtInCall6129 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25506  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6131 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25507  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6133 = new BitSet(new long[]{0x0000000010000000L});
 25508  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6135 = new BitSet(new long[]{0x0000000000000002L});
 25509  1 
     public static final BitSet FOLLOW_ISBLANK_in_builtInCall6151 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25510  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6153 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25511  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6155 = new BitSet(new long[]{0x0000000010000000L});
 25512  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6157 = new BitSet(new long[]{0x0000000000000002L});
 25513  1 
     public static final BitSet FOLLOW_ISLITERAL_in_builtInCall6174 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25514  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6176 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25515  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6178 = new BitSet(new long[]{0x0000000010000000L});
 25516  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6180 = new BitSet(new long[]{0x0000000000000002L});
 25517  1 
     public static final BitSet FOLLOW_ISNUMERIC_in_builtInCall6196 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25518  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_builtInCall6198 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25519  1 
     public static final BitSet FOLLOW_expression_in_builtInCall6200 = new BitSet(new long[]{0x0000000010000000L});
 25520  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_builtInCall6202 = new BitSet(new long[]{0x0000000000000002L});
 25521  1 
     public static final BitSet FOLLOW_regexExpression_in_builtInCall6218 = new BitSet(new long[]{0x0000000000000002L});
 25522  1 
     public static final BitSet FOLLOW_existsFunction_in_builtInCall6230 = new BitSet(new long[]{0x0000000000000002L});
 25523  1 
     public static final BitSet FOLLOW_notExistsFunction_in_builtInCall6242 = new BitSet(new long[]{0x0000000000000002L});
 25524  1 
     public static final BitSet FOLLOW_REGEX_in_regexExpression6263 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25525  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_regexExpression6265 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25526  1 
     public static final BitSet FOLLOW_expression_in_regexExpression6267 = new BitSet(new long[]{0x0000000200000000L});
 25527  1 
     public static final BitSet FOLLOW_COMMA_in_regexExpression6269 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25528  1 
     public static final BitSet FOLLOW_expression_in_regexExpression6271 = new BitSet(new long[]{0x0000000210000000L});
 25529  1 
     public static final BitSet FOLLOW_COMMA_in_regexExpression6274 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25530  1 
     public static final BitSet FOLLOW_expression_in_regexExpression6276 = new BitSet(new long[]{0x0000000010000000L});
 25531  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_regexExpression6280 = new BitSet(new long[]{0x0000000000000002L});
 25532  1 
     public static final BitSet FOLLOW_SUBSTR_in_subStringExpression6310 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25533  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_subStringExpression6312 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25534  1 
     public static final BitSet FOLLOW_expression_in_subStringExpression6314 = new BitSet(new long[]{0x0000000200000000L});
 25535  1 
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6316 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25536  1 
     public static final BitSet FOLLOW_expression_in_subStringExpression6318 = new BitSet(new long[]{0x0000000210000000L});
 25537  1 
     public static final BitSet FOLLOW_COMMA_in_subStringExpression6321 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25538  1 
     public static final BitSet FOLLOW_expression_in_subStringExpression6323 = new BitSet(new long[]{0x0000000010000000L});
 25539  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_subStringExpression6327 = new BitSet(new long[]{0x0000000000000002L});
 25540  1 
     public static final BitSet FOLLOW_EXISTS_in_existsFunction6357 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25541  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_existsFunction6359 = new BitSet(new long[]{0x0000000000000002L});
 25542  1 
     public static final BitSet FOLLOW_NOT_in_notExistsFunction6384 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
 25543  1 
     public static final BitSet FOLLOW_EXISTS_in_notExistsFunction6386 = new BitSet(new long[]{0x0000000000000000L,0x1000000000000000L});
 25544  1 
     public static final BitSet FOLLOW_groupGraphPattern_in_notExistsFunction6388 = new BitSet(new long[]{0x0000000000000002L});
 25545  1 
     public static final BitSet FOLLOW_COUNT_in_aggregate6413 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25546  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6415 = new BitSet(new long[]{0x2720F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25547  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6417 = new BitSet(new long[]{0x2700F94884C0C020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25548  1 
     public static final BitSet FOLLOW_ASTERISK_in_aggregate6421 = new BitSet(new long[]{0x0000000010000000L});
 25549  1 
     public static final BitSet FOLLOW_expression_in_aggregate6425 = new BitSet(new long[]{0x0000000010000000L});
 25550  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6428 = new BitSet(new long[]{0x0000000000000002L});
 25551  1 
     public static final BitSet FOLLOW_SUM_in_aggregate6451 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25552  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6453 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25553  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6455 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25554  1 
     public static final BitSet FOLLOW_expression_in_aggregate6458 = new BitSet(new long[]{0x0000000010000000L});
 25555  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6460 = new BitSet(new long[]{0x0000000000000002L});
 25556  1 
     public static final BitSet FOLLOW_MIN_in_aggregate6479 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25557  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6481 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25558  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6483 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25559  1 
     public static final BitSet FOLLOW_expression_in_aggregate6486 = new BitSet(new long[]{0x0000000010000000L});
 25560  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6488 = new BitSet(new long[]{0x0000000000000002L});
 25561  1 
     public static final BitSet FOLLOW_MAX_in_aggregate6507 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25562  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6509 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25563  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6511 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25564  1 
     public static final BitSet FOLLOW_expression_in_aggregate6514 = new BitSet(new long[]{0x0000000010000000L});
 25565  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6516 = new BitSet(new long[]{0x0000000000000002L});
 25566  1 
     public static final BitSet FOLLOW_AVG_in_aggregate6535 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25567  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6537 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25568  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6539 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25569  1 
     public static final BitSet FOLLOW_expression_in_aggregate6542 = new BitSet(new long[]{0x0000000010000000L});
 25570  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6544 = new BitSet(new long[]{0x0000000000000002L});
 25571  1 
     public static final BitSet FOLLOW_SAMPLE_in_aggregate6563 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25572  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6565 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25573  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6567 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25574  1 
     public static final BitSet FOLLOW_expression_in_aggregate6570 = new BitSet(new long[]{0x0000000010000000L});
 25575  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6572 = new BitSet(new long[]{0x0000000000000002L});
 25576  1 
     public static final BitSet FOLLOW_GROUP_CONCAT_in_aggregate6591 = new BitSet(new long[]{0x0000000000000000L,0x0800000000000000L});
 25577  1 
     public static final BitSet FOLLOW_OPEN_BRACE_in_aggregate6593 = new BitSet(new long[]{0x2720F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25578  1 
     public static final BitSet FOLLOW_DISTINCT_in_aggregate6595 = new BitSet(new long[]{0x2700F94884C08020L,0x0932BC2FECE62029L,0x073FFCF83F200700L,0x0000000000020C87L});
 25579  1 
     public static final BitSet FOLLOW_expression_in_aggregate6598 = new BitSet(new long[]{0x0000000010000000L,0x0000000000000000L,0x0000000100000000L});
 25580  1 
     public static final BitSet FOLLOW_SEMICOLON_in_aggregate6601 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0000000200000000L});
 25581  1 
     public static final BitSet FOLLOW_SEPARATOR_in_aggregate6603 = new BitSet(new long[]{0x8000000000000000L});
 25582  1 
     public static final BitSet FOLLOW_EQUAL_in_aggregate6605 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000000L,0x0007800000000000L});
 25583  1 
     public static final BitSet FOLLOW_string_in_aggregate6607 = new BitSet(new long[]{0x0000000010000000L});
 25584  1 
     public static final BitSet FOLLOW_CLOSE_BRACE_in_aggregate6611 = new BitSet(new long[]{0x0000000000000002L});
 25585  1 
     public static final BitSet FOLLOW_iriRef_in_iriRefOrFunction6646 = new BitSet(new long[]{0x0000000000000002L,0x0800000000000000L});
 25586  1 
     public static final BitSet FOLLOW_argList_in_iriRefOrFunction6648 = new BitSet(new long[]{0x0000000000000002L});
 25587  1 
     public static final BitSet FOLLOW_string_in_rdfLiteral6681 = new BitSet(new long[]{0x0000000000000002L,0x0000001000000000L,0x0000000000800000L});
 25588  1 
     public static final BitSet FOLLOW_LANGTAG_in_rdfLiteral6684 = new BitSet(new long[]{0x0000000000000002L});
 25589  1 
     public static final BitSet FOLLOW_REFERENCE_in_rdfLiteral6689 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L,0x0000000000000600L});
 25590  1 
     public static final BitSet FOLLOW_iriRef_in_rdfLiteral6691 = new BitSet(new long[]{0x0000000000000002L});
 25591  1 
     public static final BitSet FOLLOW_numericLiteralUnsigned_in_numericLiteral6711 = new BitSet(new long[]{0x0000000000000002L});
 25592  1 
     public static final BitSet FOLLOW_numericLiteralPositive_in_numericLiteral6719 = new BitSet(new long[]{0x0000000000000002L});
 25593  1 
     public static final BitSet FOLLOW_numericLiteralNegative_in_numericLiteral6727 = new BitSet(new long[]{0x0000000000000002L});
 25594  1 
     public static final BitSet FOLLOW_IRI_REF_in_iriRef6910 = new BitSet(new long[]{0x0000000000000002L});
 25595  1 
     public static final BitSet FOLLOW_prefixedName_in_iriRef6918 = new BitSet(new long[]{0x0000000000000002L});
 25596  1 
     public static final BitSet FOLLOW_BLANK_NODE_LABEL_in_blankNode6960 = new BitSet(new long[]{0x0000000000000002L});
 25597  1 
     public static final BitSet FOLLOW_anon_in_blankNode6968 = new BitSet(new long[]{0x0000000000000002L});
 25598  1 
     public static final BitSet FOLLOW_OPEN_SQUARE_BRACKET_in_anon6985 = new BitSet(new long[]{0x0000000040000000L});
 25599  1 
     public static final BitSet FOLLOW_CLOSE_SQUARE_BRACKET_in_anon6987 = new BitSet(new long[]{0x0000000000000002L});
 25600   
 
 25601   
 }
Report generated by Cobertura 1.9.4.1 on 25.12.11 18:03.